dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 439 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467
 468 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 469
 470 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 471 #include <dali/devel-api/adaptor-framework/image-loading.h>
 472
 473 #include <dali/public-api/events/mouse-button.h>
 474
 475 // add here SWIG version check
 476
 477 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 478 // disable Swig-dependent warnings
 479
 480 // 'identifier1' has C-linkage specified,
 481 // but returns UDT 'identifier2' which is incompatible with C
 482 #pragma warning(disable: 4190)
 483
 484 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 485 #pragma warning(disable: 4800)
 486
 487 // debug info too long etc etc
 488 #pragma warning(disable: 4786)
 489 #endif
 490
 491
 492 #include <stdexcept>
 493
 494
 495 #include <string>
 496
 497
 498 #include <vector>
 499 #include <algorithm>
 500 #include <stdexcept>
 501
 502
 503 #include <map>
 504 #include <algorithm>
 505 #include <stdexcept>
 506
 507
 508 #include <utility>
 509
 510
 511 typedef float floatp;
 512
 513 SWIGINTERN floatp *new_floatp(){
 514   return new float();
 515 }
 516 SWIGINTERN void delete_floatp(floatp *self){
 517   if (self) delete self;
 518 }
 519 SWIGINTERN void floatp_assign(floatp *self,float value){
 520   *self = value;
 521 }
 522 SWIGINTERN float floatp_value(floatp *self){
 523   return *self;
 524 }
 525 SWIGINTERN float *floatp_cast(floatp *self){
 526   return self;
 527 }
 528 SWIGINTERN floatp *floatp_frompointer(float *t){
 529   return (floatp *) t;
 530 }
 531
 532 typedef int intp;
 533
 534 SWIGINTERN intp *new_intp(){
 535   return new int();
 536 }
 537 SWIGINTERN void delete_intp(intp *self){
 538   if (self) delete self;
 539 }
 540 SWIGINTERN void intp_assign(intp *self,int value){
 541   *self = value;
 542 }
 543 SWIGINTERN int intp_value(intp *self){
 544   return *self;
 545 }
 546 SWIGINTERN int *intp_cast(intp *self){
 547   return self;
 548 }
 549 SWIGINTERN intp *intp_frompointer(int *t){
 550   return (intp *) t;
 551 }
 552
 553 typedef double doublep;
 554
 555 SWIGINTERN doublep *new_doublep(){
 556   return new double();
 557 }
 558 SWIGINTERN void delete_doublep(doublep *self){
 559   if (self) delete self;
 560 }
 561 SWIGINTERN void doublep_assign(doublep *self,double value){
 562   *self = value;
 563 }
 564 SWIGINTERN double doublep_value(doublep *self){
 565   return *self;
 566 }
 567 SWIGINTERN double *doublep_cast(doublep *self){
 568   return self;
 569 }
 570 SWIGINTERN doublep *doublep_frompointer(double *t){
 571   return (doublep *) t;
 572 }
 573
 574 typedef unsigned int uintp;
 575
 576 SWIGINTERN uintp *new_uintp(){
 577   return new unsigned int();
 578 }
 579 SWIGINTERN void delete_uintp(uintp *self){
 580   if (self) delete self;
 581 }
 582 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 583   *self = value;
 584 }
 585 SWIGINTERN unsigned int uintp_value(uintp *self){
 586   return *self;
 587 }
 588 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 589   return self;
 590 }
 591 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 592   return (uintp *) t;
 593 }
 594
 595 typedef unsigned short ushortp;
 596
 597 SWIGINTERN ushortp *new_ushortp(){
 598   return new unsigned short();
 599 }
 600 SWIGINTERN void delete_ushortp(ushortp *self){
 601   if (self) delete self;
 602 }
 603 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 604   *self = value;
 605 }
 606 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 607   return *self;
 608 }
 609 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 610   return self;
 611 }
 612 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 613   return (ushortp *) t;
 614 }
 615
 616 unsigned int int_to_uint(int x) {
 617    return (unsigned int) x;
 618 }
 619
 620
 621 using namespace Dali;
 622 using namespace Dali::Toolkit;
 623
 624 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 625 {
 626   bool result = false;
 627   try
 628   {
 629     // C++ code. DALi uses Handle <-> Body design pattern.
 630     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 631     // Handles in DALi can be converted into a boolean type
 632     // to check if the handle has a valid body attached to it.
 633     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 634     if( *self )
 635     {
 636       result = true;
 637     }
 638     else
 639     {
 640       result = false;
 641     }
 642   }
 643   catch (std::out_of_range& e)
 644   {
 645     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 646     return 0;
 647   }
 648   catch (std::exception& e)
 649   {
 650     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 651     return 0;
 652   }
 653   catch (DaliException e)
 654   {
 655     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 656     return 0;
 657   }
 658   catch (...)
 659   {
 660     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 661     return 0;
 662   }
 663   return result;
 664 }
 665
 666 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 667 {
 668   bool result = false;
 669   try
 670   {
 671     // C++ code. Check if two handles reference the same implemtion
 672     if( *self == rhs)
 673     {
 674       result = true;
 675     }
 676     else
 677     {
 678       result = false;
 679     }
 680   }
 681   catch (std::out_of_range& e)
 682   {
 683     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 684     return 0;
 685   }
 686   catch (std::exception& e)
 687   {
 688     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 689     return 0;
 690   }
 691   catch (DaliException e)
 692   {
 693     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 694     return 0;
 695   }
 696   catch (...)
 697   {
 698     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 699     return 0;
 700   }
 701   return result;
 702 }
 703
 704
 705 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 706      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 707    }
 708 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 709      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 710    }
 711 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 712         std::vector< Dali::TouchPoint >* pv = 0;
 713         if (capacity >= 0) {
 714           pv = new std::vector< Dali::TouchPoint >();
 715           pv->reserve(capacity);
 716        } else {
 717           throw std::out_of_range("capacity");
 718        }
 719        return pv;
 720       }
 721 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 722         if (index>=0 && index<(int)self->size())
 723           return (*self)[index];
 724         else
 725           throw std::out_of_range("index");
 726       }
 727 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 728         if (index>=0 && index<(int)self->size())
 729           return (*self)[index];
 730         else
 731           throw std::out_of_range("index");
 732       }
 733 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 734         if (index>=0 && index<(int)self->size())
 735           (*self)[index] = val;
 736         else
 737           throw std::out_of_range("index");
 738       }
 739 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 740         self->insert(self->end(), values.begin(), values.end());
 741       }
 742 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 743         if (index < 0)
 744           throw std::out_of_range("index");
 745         if (count < 0)
 746           throw std::out_of_range("count");
 747         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 748           throw std::invalid_argument("invalid range");
 749         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 750       }
 751 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 752         if (index>=0 && index<(int)self->size()+1)
 753           self->insert(self->begin()+index, x);
 754         else
 755           throw std::out_of_range("index");
 756       }
 757 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 758         if (index>=0 && index<(int)self->size()+1)
 759           self->insert(self->begin()+index, values.begin(), values.end());
 760         else
 761           throw std::out_of_range("index");
 762       }
 763 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 764         if (index>=0 && index<(int)self->size())
 765           self->erase(self->begin() + index);
 766         else
 767           throw std::out_of_range("index");
 768       }
 769 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 770         if (index < 0)
 771           throw std::out_of_range("index");
 772         if (count < 0)
 773           throw std::out_of_range("count");
 774         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 775           throw std::invalid_argument("invalid range");
 776         self->erase(self->begin()+index, self->begin()+index+count);
 777       }
 778 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 779         if (count < 0)
 780           throw std::out_of_range("count");
 781         return new std::vector< Dali::TouchPoint >(count, value);
 782       }
 783 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 784         std::reverse(self->begin(), self->end());
 785       }
 786 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 787         if (index < 0)
 788           throw std::out_of_range("index");
 789         if (count < 0)
 790           throw std::out_of_range("count");
 791         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 792           throw std::invalid_argument("invalid range");
 793         std::reverse(self->begin()+index, self->begin()+index+count);
 794       }
 795 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 796         if (index < 0)
 797           throw std::out_of_range("index");
 798         if (index+values.size() > self->size())
 799           throw std::out_of_range("index");
 800         std::copy(values.begin(), values.end(), self->begin()+index);
 801       }
 802 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 803          return self->Empty();
 804       }
 805 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 806         return self->GetConnectionCount();
 807       }
 808 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 809           self->Connect( func );
 810       }
 811 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 812           self->Disconnect( func );
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 815           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 816 /*@SWIG@*/ self->Emit( arg );
 817       }
 818 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 819          return self->Empty();
 820       }
 821 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 822         return self->GetConnectionCount();
 823       }
 824 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 825           self->Connect( func );
 826       }
 827 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 828           self->Disconnect( func );
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 831           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 832 /*@SWIG@*/ self->Emit( arg );
 833       }
 834 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 835          return self->Empty();
 836       }
 837 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 838         return self->GetConnectionCount();
 839       }
 840 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 841           self->Connect( func );
 842       }
 843 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 844           self->Disconnect( func );
 845       }
 846 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 847           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 848 /*@SWIG@*/ self->Emit( arg );
 849       }
 850 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 851          return self->Empty();
 852       }
 853 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 854         return self->GetConnectionCount();
 855       }
 856 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 857           self->Connect( func );
 858       }
 859 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 860           self->Disconnect( func );
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 863           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 864 /*@SWIG@*/ self->Emit( arg );
 865       }
 866 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 867          return self->Empty();
 868       }
 869 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 870         return self->GetConnectionCount();
 871       }
 872 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 873           self->Connect( func );
 874       }
 875 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 876           self->Disconnect( func );
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 879           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 880 /*@SWIG@*/ self->Emit( arg );
 881       }
 882 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 883          return self->Empty();
 884       }
 885 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 886         return self->GetConnectionCount();
 887       }
 888 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 889         self->Connect( func );
 890       }
 891 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 892         self->Disconnect( func );
 893       }
 894 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 895         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 896 /*@SWIG@*/ self->Emit( arg1, arg2 );
 897       }
 898 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 899          return self->Empty();
 900       }
 901 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 902         return self->GetConnectionCount();
 903       }
 904 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 905         self->Connect( func );
 906       }
 907 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 908         self->Disconnect( func );
 909       }
 910 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 911         return self->Emit( arg1, arg2 );
 912       }
 913 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 914          return self->Empty();
 915       }
 916 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 917         return self->GetConnectionCount();
 918       }
 919 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 920         self->Connect( func );
 921       }
 922 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 923         self->Disconnect( func );
 924       }
 925 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 926         return self->Emit( arg1, arg2 );
 927       }
 928 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 929          return self->Empty();
 930       }
 931 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 932         return self->GetConnectionCount();
 933       }
 934 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 935         self->Connect( func );
 936       }
 937 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 938         self->Disconnect( func );
 939       }
 940 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 941         return self->Emit( arg1, arg2 );
 942       }
 943 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 944          return self->Empty();
 945       }
 946 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 947         return self->GetConnectionCount();
 948       }
 949 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 950           self->Connect( func );
 951       }
 952 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 953           self->Disconnect( func );
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 956           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 957 /*@SWIG@*/ self->Emit( arg );
 958       }
 959 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 960          return self->Empty();
 961       }
 962 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 963         return self->GetConnectionCount();
 964       }
 965 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 966           self->Connect( func );
 967       }
 968 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 969           self->Disconnect( func );
 970       }
 971 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 972           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 973 /*@SWIG@*/ self->Emit( arg );
 974       }
 975 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 976          return self->Empty();
 977       }
 978 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 979         return self->GetConnectionCount();
 980       }
 981 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 982           self->Connect( func );
 983       }
 984 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 985           self->Disconnect( func );
 986       }
 987 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 988           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 989 /*@SWIG@*/ self->Emit( arg );
 990       }
 991 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 992          return self->Empty();
 993       }
 994 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 995         return self->GetConnectionCount();
 996       }
 997 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 998           self->Connect( func );
 999       }
1000 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1001           self->Disconnect( func );
1002       }
1003 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1004           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1005 /*@SWIG@*/ self->Emit( arg );
1006       }
1007 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1008          return self->Empty();
1009       }
1010 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1011         return self->GetConnectionCount();
1012       }
1013 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1014         self->Connect( func );
1015       }
1016 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1017         self->Disconnect( func );
1018       }
1019 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1020         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1021 /*@SWIG@*/ self->Emit( arg1, arg2 );
1022       }
1023 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1024          return self->Empty();
1025       }
1026 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1027         return self->GetConnectionCount();
1028       }
1029 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1030         self->Connect( func );
1031       }
1032 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1033         self->Disconnect( func );
1034       }
1035 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1036         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1037 /*@SWIG@*/ self->Emit( arg1, arg2 );
1038       }
1039 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1040          return self->Empty();
1041       }
1042 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1043         return self->GetConnectionCount();
1044       }
1045 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1046         self->Connect( func );
1047       }
1048 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1049         self->Disconnect( func );
1050       }
1051 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1052         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1053 /*@SWIG@*/ self->Emit( arg1, arg2 );
1054       }
1055 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1056          return self->Empty();
1057       }
1058 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1059         return self->GetConnectionCount();
1060       }
1061 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1062           self->Connect( func );
1063       }
1064 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1065           self->Disconnect( func );
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1068           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1069 /*@SWIG@*/ self->Emit( arg );
1070       }
1071 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1072          return self->Empty();
1073       }
1074 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1075         return self->GetConnectionCount();
1076       }
1077 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1078           return self->Connect( func );
1079       }
1080 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1081           self->Disconnect( func );
1082       }
1083 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1084           self->Emit( arg1, arg3 );
1085       }
1086 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1087          return self->Empty();
1088       }
1089 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1090         return self->GetConnectionCount();
1091       }
1092 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1093           return self->Connect( func );
1094       }
1095 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1096           self->Disconnect( func );
1097       }
1098 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1099           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1100 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1101       }
1102
1103 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1104          return self->Empty();
1105       }
1106 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1107         return self->GetConnectionCount();
1108       }
1109 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1110           self->Connect( func );
1111       }
1112 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1113           self->Disconnect( func );
1114       }
1115 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1116           return self->Emit();
1117       }
1118
1119 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1120         std::vector< unsigned int >* pv = 0;
1121         if (capacity >= 0) {
1122           pv = new std::vector< unsigned int >();
1123           pv->reserve(capacity);
1124        } else {
1125           throw std::out_of_range("capacity");
1126        }
1127        return pv;
1128       }
1129 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1130         if (index>=0 && index<(int)self->size())
1131           return (*self)[index];
1132         else
1133           throw std::out_of_range("index");
1134       }
1135 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1142         if (index>=0 && index<(int)self->size())
1143           (*self)[index] = val;
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1148         self->insert(self->end(), values.begin(), values.end());
1149       }
1150 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1151         if (index < 0)
1152           throw std::out_of_range("index");
1153         if (count < 0)
1154           throw std::out_of_range("count");
1155         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1156           throw std::invalid_argument("invalid range");
1157         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1158       }
1159 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1160         if (index>=0 && index<(int)self->size()+1)
1161           self->insert(self->begin()+index, x);
1162         else
1163           throw std::out_of_range("index");
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, values.begin(), values.end());
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1172         if (index>=0 && index<(int)self->size())
1173           self->erase(self->begin() + index);
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1178         if (index < 0)
1179           throw std::out_of_range("index");
1180         if (count < 0)
1181           throw std::out_of_range("count");
1182         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1183           throw std::invalid_argument("invalid range");
1184         self->erase(self->begin()+index, self->begin()+index+count);
1185       }
1186 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1187         if (count < 0)
1188           throw std::out_of_range("count");
1189         return new std::vector< unsigned int >(count, value);
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1192         std::reverse(self->begin(), self->end());
1193       }
1194 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1195         if (index < 0)
1196           throw std::out_of_range("index");
1197         if (count < 0)
1198           throw std::out_of_range("count");
1199         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1200           throw std::invalid_argument("invalid range");
1201         std::reverse(self->begin()+index, self->begin()+index+count);
1202       }
1203 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1204         if (index < 0)
1205           throw std::out_of_range("index");
1206         if (index+values.size() > self->size())
1207           throw std::out_of_range("index");
1208         std::copy(values.begin(), values.end(), self->begin()+index);
1209       }
1210 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1211         return std::find(self->begin(), self->end(), value) != self->end();
1212       }
1213 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1214         int index = -1;
1215         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1216         if (it != self->end())
1217           index = (int)(it - self->begin());
1218         return index;
1219       }
1220 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1221         int index = -1;
1222         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1223         if (rit != self->rend())
1224           index = (int)(self->rend() - 1 - rit);
1225         return index;
1226       }
1227 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1228         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1229         if (it != self->end()) {
1230           self->erase(it);
1231           return true;
1232         }
1233         return false;
1234       }
1235 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1236         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1237         if (capacity >= 0) {
1238           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1239           pv->reserve(capacity);
1240        } else {
1241           throw std::out_of_range("capacity");
1242        }
1243        return pv;
1244       }
1245 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1246         if (index>=0 && index<(int)self->size())
1247           return (*self)[index];
1248         else
1249           throw std::out_of_range("index");
1250       }
1251 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1252         if (index>=0 && index<(int)self->size())
1253           return (*self)[index];
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1258         if (index>=0 && index<(int)self->size())
1259           (*self)[index] = val;
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1264         self->insert(self->end(), values.begin(), values.end());
1265       }
1266 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1267         if (index < 0)
1268           throw std::out_of_range("index");
1269         if (count < 0)
1270           throw std::out_of_range("count");
1271         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1272           throw std::invalid_argument("invalid range");
1273         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1274       }
1275 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1276         if (index>=0 && index<(int)self->size()+1)
1277           self->insert(self->begin()+index, x);
1278         else
1279           throw std::out_of_range("index");
1280       }
1281 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1282         if (index>=0 && index<(int)self->size()+1)
1283           self->insert(self->begin()+index, values.begin(), values.end());
1284         else
1285           throw std::out_of_range("index");
1286       }
1287 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1288         if (index>=0 && index<(int)self->size())
1289           self->erase(self->begin() + index);
1290         else
1291           throw std::out_of_range("index");
1292       }
1293 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1294         if (index < 0)
1295           throw std::out_of_range("index");
1296         if (count < 0)
1297           throw std::out_of_range("count");
1298         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1299           throw std::invalid_argument("invalid range");
1300         self->erase(self->begin()+index, self->begin()+index+count);
1301       }
1302 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1303         if (count < 0)
1304           throw std::out_of_range("count");
1305         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1306       }
1307 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1308         std::reverse(self->begin(), self->end());
1309       }
1310 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1311         if (index < 0)
1312           throw std::out_of_range("index");
1313         if (count < 0)
1314           throw std::out_of_range("count");
1315         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1316           throw std::invalid_argument("invalid range");
1317         std::reverse(self->begin()+index, self->begin()+index+count);
1318       }
1319 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1320         if (index < 0)
1321           throw std::out_of_range("index");
1322         if (index+values.size() > self->size())
1323           throw std::out_of_range("index");
1324         std::copy(values.begin(), values.end(), self->begin()+index);
1325       }
1326 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1327         std::vector< Dali::Actor >* pv = 0;
1328         if (capacity >= 0) {
1329           pv = new std::vector< Dali::Actor >();
1330           pv->reserve(capacity);
1331        } else {
1332           throw std::out_of_range("capacity");
1333        }
1334        return pv;
1335       }
1336 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1337         if (index>=0 && index<(int)self->size())
1338           return (*self)[index];
1339         else
1340           throw std::out_of_range("index");
1341       }
1342 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1343         if (index>=0 && index<(int)self->size())
1344           return (*self)[index];
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1349         if (index>=0 && index<(int)self->size())
1350           (*self)[index] = val;
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1355         self->insert(self->end(), values.begin(), values.end());
1356       }
1357 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1358         if (index < 0)
1359           throw std::out_of_range("index");
1360         if (count < 0)
1361           throw std::out_of_range("count");
1362         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1363           throw std::invalid_argument("invalid range");
1364         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1365       }
1366 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1367         if (index>=0 && index<(int)self->size()+1)
1368           self->insert(self->begin()+index, x);
1369         else
1370           throw std::out_of_range("index");
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1373         if (index>=0 && index<(int)self->size()+1)
1374           self->insert(self->begin()+index, values.begin(), values.end());
1375         else
1376           throw std::out_of_range("index");
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1379         if (index>=0 && index<(int)self->size())
1380           self->erase(self->begin() + index);
1381         else
1382           throw std::out_of_range("index");
1383       }
1384 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1385         if (index < 0)
1386           throw std::out_of_range("index");
1387         if (count < 0)
1388           throw std::out_of_range("count");
1389         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1390           throw std::invalid_argument("invalid range");
1391         self->erase(self->begin()+index, self->begin()+index+count);
1392       }
1393 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1394         if (count < 0)
1395           throw std::out_of_range("count");
1396         return new std::vector< Dali::Actor >(count, value);
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1399         std::reverse(self->begin(), self->end());
1400       }
1401 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1402         if (index < 0)
1403           throw std::out_of_range("index");
1404         if (count < 0)
1405           throw std::out_of_range("count");
1406         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1407           throw std::invalid_argument("invalid range");
1408         std::reverse(self->begin()+index, self->begin()+index+count);
1409       }
1410 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1411         if (index < 0)
1412           throw std::out_of_range("index");
1413         if (index+values.size() > self->size())
1414           throw std::out_of_range("index");
1415         std::copy(values.begin(), values.end(), self->begin()+index);
1416       }
1417 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1418          return self->Empty();
1419       }
1420 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1421         return self->GetConnectionCount();
1422       }
1423 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1424           self->Connect( func );
1425       }
1426 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1427           self->Disconnect( func );
1428       }
1429 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1430           return self->Emit( arg );
1431       }
1432 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1433          return self->Empty();
1434       }
1435 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1436         return self->GetConnectionCount();
1437       }
1438 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1439         self->Connect( func );
1440       }
1441 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1442         self->Disconnect( func );
1443       }
1444 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1445         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1446 /*@SWIG@*/ self->Emit( arg1, arg2 );
1447       }
1448 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1449          return self->Empty();
1450       }
1451 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1452         return self->GetConnectionCount();
1453       }
1454 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1455         self->Connect( func );
1456       }
1457 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1458         self->Disconnect( func );
1459       }
1460 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1461         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1462 /*@SWIG@*/ self->Emit( arg1, arg2 );
1463       }
1464 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1465          return self->Empty();
1466       }
1467 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1468         return self->GetConnectionCount();
1469       }
1470 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1471         self->Connect( func );
1472       }
1473 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1474         self->Disconnect( func );
1475       }
1476 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1477         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1478 /*@SWIG@*/ self->Emit( arg1, arg2 );
1479       }
1480 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1481          return self->Empty();
1482       }
1483 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1484         return self->GetConnectionCount();
1485       }
1486 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1487         self->Connect( func );
1488       }
1489 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1490         self->Disconnect( func );
1491       }
1492 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1493         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1494 /*@SWIG@*/ self->Emit( arg1, arg2 );
1495       }
1496 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1497          return self->Empty();
1498       }
1499 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1500         return self->GetConnectionCount();
1501       }
1502 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1503           self->Connect( func );
1504       }
1505 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1506           self->Disconnect( func );
1507       }
1508 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1509           return self->Emit( arg );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1512          return self->Empty();
1513       }
1514 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1515         return self->GetConnectionCount();
1516       }
1517 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1518           self->Connect( func );
1519       }
1520 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1521           self->Disconnect( func );
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1524           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1525 /*@SWIG@*/ self->Emit( arg );
1526       }
1527 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1528          return self->Empty();
1529       }
1530 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1531         return self->GetConnectionCount();
1532       }
1533 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1534           return self->Connect( func );
1535       }
1536 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1537           self->Disconnect( func );
1538       }
1539 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1540           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1541 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1542       }
1543 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1544          return self->Empty();
1545       }
1546 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1547         return self->GetConnectionCount();
1548       }
1549 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1550           self->Connect( func );
1551       }
1552 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1553           self->Disconnect( func );
1554       }
1555 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1556           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1557 /*@SWIG@*/ self->Emit( arg );
1558       }
1559 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1560          return self->Empty();
1561       }
1562 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1563         return self->GetConnectionCount();
1564       }
1565 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1566           return self->Connect( func );
1567       }
1568 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1569           self->Disconnect( func );
1570       }
1571 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1572           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1573 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1574       }
1575 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1576          return self->Empty();
1577       }
1578 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1579         return self->GetConnectionCount();
1580       }
1581 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1582           self->Connect( func );
1583       }
1584 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1585           self->Disconnect( func );
1586       }
1587 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1588           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1589 /*@SWIG@*/ self->Emit( arg );
1590       }
1591 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1592          return self->Empty();
1593       }
1594 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1595         return self->GetConnectionCount();
1596       }
1597 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1598           self->Connect( func );
1599       }
1600 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1601           self->Disconnect( func );
1602       }
1603 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1604           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1605 /*@SWIG@*/ self->Emit( arg );
1606       }
1607
1608
1609 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1610          return self->Empty();
1611       }
1612 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1613         return self->GetConnectionCount();
1614       }
1615 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1616         self->Connect( func );
1617       }
1618 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1619         self->Disconnect( func );
1620       }
1621 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1622         return self->Emit( arg1, arg2 );
1623       }
1624 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1625          return self->Empty();
1626       }
1627 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1628         return self->GetConnectionCount();
1629       }
1630 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1631           self->Connect( func );
1632       }
1633 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1634           self->Disconnect( func );
1635       }
1636 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1637           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1638 /*@SWIG@*/ self->Emit( arg );
1639       }
1640 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1641          return self->Empty();
1642       }
1643 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1644         return self->GetConnectionCount();
1645       }
1646 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1647           self->Connect( func );
1648       }
1649 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1650           self->Disconnect( func );
1651       }
1652 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1653           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1654 /*@SWIG@*/ self->Emit( arg );
1655       }
1656 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1657          return self->Empty();
1658       }
1659 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1660         return self->GetConnectionCount();
1661       }
1662 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1663         self->Connect( func );
1664       }
1665 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1666         self->Disconnect( func );
1667       }
1668 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1669         return self->Emit( arg1, arg2 );
1670       }
1671 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1672          return self->Empty();
1673       }
1674 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1675         return self->GetConnectionCount();
1676       }
1677 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1678         self->Connect( func );
1679       }
1680 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1681         self->Disconnect( func );
1682       }
1683 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1684         return self->Emit( arg1, arg2 );
1685       }
1686
1687
1688 /* ---------------------------------------------------
1689  * C++ director class methods
1690  * --------------------------------------------------- */
1691
1692 #include "dali_wrap.h"
1693
1694 /*
1695  *  Widget director
1696  */
1697 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1698   swig_init_callbacks();
1699 }
1700
1701 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1702 }
1703
1704 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1705   char * jcontentInfo = 0 ;
1706   void * jwindow  ;
1707
1708   if (!swig_callbackOnCreate) {
1709     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1710     return;
1711   } else {
1712     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1713     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1714     swig_callbackOnCreate(jcontentInfo, jwindow);
1715   }
1716 }
1717
1718 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1719   char * jcontentInfo = 0 ;
1720   int jtype  ;
1721
1722   if (!swig_callbackOnTerminate) {
1723     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1724     return;
1725   } else {
1726     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1727     jtype = (int)type;
1728     swig_callbackOnTerminate(jcontentInfo, jtype);
1729   }
1730 }
1731
1732 void SwigDirector_WidgetImpl::OnPause() {
1733   if (!swig_callbackOnPause) {
1734     Dali::Internal::Adaptor::Widget::OnPause();
1735     return;
1736   } else {
1737     swig_callbackOnPause();
1738   }
1739 }
1740
1741 void SwigDirector_WidgetImpl::OnResume() {
1742   if (!swig_callbackOnResume) {
1743     Dali::Internal::Adaptor::Widget::OnResume();
1744     return;
1745   } else {
1746     swig_callbackOnResume();
1747   }
1748 }
1749
1750 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1751   void * jwindow  ;
1752
1753   if (!swig_callbackOnResize) {
1754     Dali::Internal::Adaptor::Widget::OnResize(window);
1755     return;
1756   } else {
1757     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1758     swig_callbackOnResize(jwindow);
1759   }
1760 }
1761
1762 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1763   char * jcontentInfo = 0 ;
1764   int jforce  ;
1765
1766   if (!swig_callbackOnUpdate) {
1767     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1768     return;
1769   } else {
1770     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1771     jforce = force;
1772     swig_callbackOnUpdate(jcontentInfo, jforce);
1773   }
1774 }
1775
1776 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1777   void * jslotObserver = 0 ;
1778   void * jcallback = 0 ;
1779
1780   if (!swig_callbackSignalConnected) {
1781     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1782     return;
1783   } else {
1784     jslotObserver = (void *) slotObserver;
1785     jcallback = (void *) callback;
1786     swig_callbackSignalConnected(jslotObserver, jcallback);
1787   }
1788 }
1789
1790 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1791   void * jslotObserver = 0 ;
1792   void * jcallback = 0 ;
1793
1794   if (!swig_callbackSignalDisconnected) {
1795     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1796     return;
1797   } else {
1798     jslotObserver = (void *) slotObserver;
1799     jcallback = (void *) callback;
1800     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1801   }
1802 }
1803
1804 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1805
1806   swig_callbackOnCreate = callbackOnCreate;
1807   swig_callbackOnTerminate = callbackOnTerminate;
1808   swig_callbackOnPause = callbackOnPause;
1809   swig_callbackOnResume = callbackOnResume;
1810   swig_callbackOnResize = callbackOnResize;
1811   swig_callbackOnUpdate = callbackOnUpdate;
1812   swig_callbackSignalConnected = callbackSignalConnected;
1813   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1814 }
1815
1816 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1817   swig_callbackOnCreate = 0;
1818   swig_callbackOnTerminate = 0;
1819   swig_callbackOnPause = 0;
1820   swig_callbackOnResume = 0;
1821   swig_callbackOnResize = 0;
1822   swig_callbackOnUpdate = 0;
1823   swig_callbackSignalConnected = 0;
1824   swig_callbackSignalDisconnected = 0;
1825 }
1826
1827
1828 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1829   swig_init_callbacks();
1830 }
1831
1832 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1833
1834 }
1835
1836
1837 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1838   int jdepth  ;
1839
1840   if (!swig_callbackOnStageConnection) {
1841     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1842     return;
1843   } else {
1844     jdepth = depth;
1845     swig_callbackOnStageConnection(jdepth);
1846   }
1847 }
1848
1849 void SwigDirector_ViewImpl::OnStageDisconnection() {
1850   if (!swig_callbackOnStageDisconnection) {
1851     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1852     return;
1853   } else {
1854     swig_callbackOnStageDisconnection();
1855   }
1856 }
1857
1858 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1859   void * jchild = 0 ;
1860
1861   if (!swig_callbackOnChildAdd) {
1862     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1863     return;
1864   } else {
1865     jchild = (Dali::Actor *) &child;
1866     swig_callbackOnChildAdd(jchild);
1867   }
1868 }
1869
1870 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1871   void * jchild = 0 ;
1872
1873   if (!swig_callbackOnChildRemove) {
1874     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1875     return;
1876   } else {
1877     jchild = (Dali::Actor *) &child;
1878     swig_callbackOnChildRemove(jchild);
1879   }
1880 }
1881
1882 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1883   int jindex  ;
1884   void * jpropertyValue  ;
1885
1886   if (!swig_callbackOnPropertySet) {
1887     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1888     return;
1889   } else {
1890     jindex = index;
1891     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1892     swig_callbackOnPropertySet(jindex, jpropertyValue);
1893   }
1894 }
1895
1896 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1897   void * jtargetSize = 0 ;
1898
1899   if (!swig_callbackOnSizeSet) {
1900     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1901     return;
1902   } else {
1903     jtargetSize = (Dali::Vector3 *) &targetSize;
1904     swig_callbackOnSizeSet(jtargetSize);
1905   }
1906 }
1907
1908 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1909   void * janimation = 0 ;
1910   void * jtargetSize = 0 ;
1911
1912   if (!swig_callbackOnSizeAnimation) {
1913     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1914     return;
1915   } else {
1916     janimation = (Dali::Animation *) &animation;
1917     jtargetSize = (Dali::Vector3 *) &targetSize;
1918     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1919   }
1920 }
1921
1922 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1923   bool c_result = SwigValueInit< bool >() ;
1924   unsigned int jresult = 0 ;
1925   void * jarg0 = 0 ;
1926
1927   if (!swig_callbackOnTouchEvent) {
1928     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1929   } else {
1930     jarg0 = (Dali::TouchEvent *) &event;
1931     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1932     c_result = jresult ? true : false;
1933   }
1934   return c_result;
1935 }
1936
1937 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1938   bool c_result = SwigValueInit< bool >() ;
1939   unsigned int jresult = 0 ;
1940   void * jarg0 = 0 ;
1941
1942   if (!swig_callbackOnHoverEvent) {
1943     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1944   } else {
1945     jarg0 = (Dali::HoverEvent *) &event;
1946     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1947     c_result = jresult ? true : false;
1948   }
1949   return c_result;
1950 }
1951
1952 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1953   bool c_result = SwigValueInit< bool >() ;
1954   unsigned int jresult = 0 ;
1955   void * jarg0 = 0 ;
1956
1957   if (!swig_callbackOnKeyEvent) {
1958     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1959   } else {
1960     jarg0 = (Dali::KeyEvent *) &event;
1961     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1962     c_result = jresult ? true : false;
1963   }
1964   return c_result;
1965 }
1966
1967 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1968   bool c_result = SwigValueInit< bool >() ;
1969   unsigned int jresult = 0 ;
1970   void * jarg0 = 0 ;
1971
1972   if (!swig_callbackOnWheelEvent) {
1973     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1974   } else {
1975     jarg0 = (Dali::WheelEvent *) &event;
1976     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1977     c_result = jresult ? true : false;
1978   }
1979   return c_result;
1980 }
1981
1982 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1983   void * jsize = 0 ;
1984   void * jcontainer = 0 ;
1985
1986   if (!swig_callbackOnRelayout) {
1987     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1988     return;
1989   } else {
1990     jsize = (Dali::Vector2 *) &size;
1991     jcontainer = (Dali::RelayoutContainer *) &container;
1992     swig_callbackOnRelayout(jsize, jcontainer);
1993   }
1994 }
1995
1996 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1997   int jpolicy  ;
1998   int jdimension  ;
1999
2000   if (!swig_callbackOnSetResizePolicy) {
2001     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2002     return;
2003   } else {
2004     jpolicy = (int)policy;
2005     jdimension = (int)dimension;
2006     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2007   }
2008 }
2009
2010 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2011   Dali::Vector3 c_result ;
2012   void * jresult = 0 ;
2013
2014   if (!swig_callbackGetNaturalSize) {
2015     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2016   } else {
2017     jresult = (void *) swig_callbackGetNaturalSize();
2018     if (!jresult) {
2019       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2020       return c_result;
2021     }
2022     c_result = *(Dali::Vector3 *)jresult;
2023   }
2024   return c_result;
2025 }
2026
2027 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2028   float c_result = SwigValueInit< float >() ;
2029   float jresult = 0 ;
2030   void * jchild = 0 ;
2031   int jdimension  ;
2032
2033   if (!swig_callbackCalculateChildSize) {
2034     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2035   } else {
2036     jchild = (Dali::Actor *) &child;
2037     jdimension = (int)dimension;
2038     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2039     c_result = (float)jresult;
2040   }
2041   return c_result;
2042 }
2043
2044 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2045   float c_result = SwigValueInit< float >() ;
2046   float jresult = 0 ;
2047   float jwidth  ;
2048
2049   if (!swig_callbackGetHeightForWidth) {
2050     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2051   } else {
2052     jwidth = width;
2053     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2054     c_result = (float)jresult;
2055   }
2056   return c_result;
2057 }
2058
2059 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2060   float c_result = SwigValueInit< float >() ;
2061   float jresult = 0 ;
2062   float jheight  ;
2063
2064   if (!swig_callbackGetWidthForHeight) {
2065     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2066   } else {
2067     jheight = height;
2068     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2069     c_result = (float)jresult;
2070   }
2071   return c_result;
2072 }
2073
2074 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2075   bool c_result = SwigValueInit< bool >() ;
2076   unsigned int jresult = 0 ;
2077   int jdimension  ;
2078
2079   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2080     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2081   } else {
2082     jdimension = (int)dimension;
2083     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2084     c_result = jresult ? true : false;
2085   }
2086   return c_result;
2087 }
2088
2089 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2090   int jdimension  ;
2091
2092   if (!swig_callbackOnCalculateRelayoutSize) {
2093     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2094     return;
2095   } else {
2096     jdimension = (int)dimension;
2097     swig_callbackOnCalculateRelayoutSize(jdimension);
2098   }
2099 }
2100
2101 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2102   float jsize  ;
2103   int jdimension  ;
2104
2105   if (!swig_callbackOnLayoutNegotiated) {
2106     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2107     return;
2108   } else {
2109     jsize = size;
2110     jdimension = (int)dimension;
2111     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2112   }
2113 }
2114
2115 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2116   return Dali::CustomActorImpl::GetExtension();
2117 }
2118
2119 void SwigDirector_ViewImpl::OnInitialize() {
2120   if (!swig_callbackOnInitialize) {
2121     Dali::Toolkit::Internal::Control::OnInitialize();
2122     return;
2123   } else {
2124     swig_callbackOnInitialize();
2125   }
2126 }
2127
2128 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2129   void * jchild = 0 ;
2130
2131   if (!swig_callbackOnControlChildAdd) {
2132     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2133     return;
2134   } else {
2135     jchild = (Dali::Actor *) &child;
2136     swig_callbackOnControlChildAdd(jchild);
2137   }
2138 }
2139
2140 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2141   void * jchild = 0 ;
2142
2143   if (!swig_callbackOnControlChildRemove) {
2144     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2145     return;
2146   } else {
2147     jchild = (Dali::Actor *) &child;
2148     swig_callbackOnControlChildRemove(jchild);
2149   }
2150 }
2151
2152 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2153   void * jstyleManager  ;
2154   int jchange  ;
2155
2156   if (!swig_callbackOnStyleChange) {
2157     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2158     return;
2159   } else {
2160     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2161     jchange = (int)change;
2162     swig_callbackOnStyleChange(jstyleManager, jchange);
2163   }
2164 }
2165
2166 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2167   bool c_result = SwigValueInit< bool >() ;
2168   unsigned int jresult = 0 ;
2169
2170   if (!swig_callbackOnAccessibilityActivated) {
2171     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2172   } else {
2173     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2174     c_result = jresult ? true : false;
2175   }
2176   return c_result;
2177 }
2178
2179 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2180   bool c_result = SwigValueInit< bool >() ;
2181   unsigned int jresult = 0 ;
2182   void * jgesture  ;
2183
2184   if (!swig_callbackOnAccessibilityPan) {
2185     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2186   } else {
2187     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2188     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2189     c_result = jresult ? true : false;
2190   }
2191   return c_result;
2192 }
2193
2194 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2195   bool c_result = SwigValueInit< bool >() ;
2196   unsigned int jresult = 0 ;
2197   void * jtouchEvent = 0 ;
2198
2199   if (!swig_callbackOnAccessibilityTouch) {
2200     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2201   } else {
2202     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2203     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2204     c_result = jresult ? true : false;
2205   }
2206   return c_result;
2207 }
2208
2209 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2210   bool c_result = SwigValueInit< bool >() ;
2211   unsigned int jresult = 0 ;
2212   unsigned int jisIncrease  ;
2213
2214   if (!swig_callbackOnAccessibilityValueChange) {
2215     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2216   } else {
2217     jisIncrease = isIncrease;
2218     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2219     c_result = jresult ? true : false;
2220   }
2221   return c_result;
2222 }
2223
2224 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2225   bool c_result = SwigValueInit< bool >() ;
2226   unsigned int jresult = 0 ;
2227
2228   if (!swig_callbackOnAccessibilityZoom) {
2229     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2230   } else {
2231     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2232     c_result = jresult ? true : false;
2233   }
2234   return c_result;
2235 }
2236
2237 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2238   if (!swig_callbackOnKeyInputFocusGained) {
2239     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2240     return;
2241   } else {
2242     swig_callbackOnKeyInputFocusGained();
2243   }
2244 }
2245
2246 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2247   if (!swig_callbackOnKeyInputFocusLost) {
2248     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2249     return;
2250   } else {
2251     swig_callbackOnKeyInputFocusLost();
2252   }
2253 }
2254
2255 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2256   Dali::Actor c_result ;
2257   void * jresult = 0 ;
2258   void * jcurrentFocusedActor  ;
2259   int jdirection  ;
2260   unsigned int jloopEnabled  ;
2261
2262   if (!swig_callbackGetNextKeyboardFocusableActor) {
2263     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2264   } else {
2265     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2266     jdirection = (int)direction;
2267     jloopEnabled = loopEnabled;
2268     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2269     if (!jresult) {
2270       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2271       return c_result;
2272     }
2273     c_result = *(Dali::Actor *)jresult;
2274   }
2275   return c_result;
2276 }
2277
2278 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2279   void * jcommitedFocusableActor  ;
2280
2281   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2282     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2283     return;
2284   } else {
2285     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2286     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2287   }
2288 }
2289
2290 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2291   bool c_result = SwigValueInit< bool >() ;
2292   unsigned int jresult = 0 ;
2293
2294   if (!swig_callbackOnKeyboardEnter) {
2295     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2296   } else {
2297     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2298     c_result = jresult ? true : false;
2299   }
2300   return c_result;
2301 }
2302
2303 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2304   void * jpinch = 0 ;
2305
2306   if (!swig_callbackOnPinch) {
2307     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2308     return;
2309   } else {
2310     jpinch = (Dali::PinchGesture *) &pinch;
2311     swig_callbackOnPinch(jpinch);
2312   }
2313 }
2314
2315 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2316   void * jpan = 0 ;
2317
2318   if (!swig_callbackOnPan) {
2319     Dali::Toolkit::Internal::Control::OnPan(pan);
2320     return;
2321   } else {
2322     jpan = (Dali::PanGesture *) &pan;
2323     swig_callbackOnPan(jpan);
2324   }
2325 }
2326
2327 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2328   void * jtap = 0 ;
2329
2330   if (!swig_callbackOnTap) {
2331     Dali::Toolkit::Internal::Control::OnTap(tap);
2332     return;
2333   } else {
2334     jtap = (Dali::TapGesture *) &tap;
2335     swig_callbackOnTap(jtap);
2336   }
2337 }
2338
2339 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2340   void * jlongPress = 0 ;
2341
2342   if (!swig_callbackOnLongPress) {
2343     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2344     return;
2345   } else {
2346     jlongPress = (Dali::LongPressGesture *) &longPress;
2347     swig_callbackOnLongPress(jlongPress);
2348   }
2349 }
2350
2351 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2352   void * jslotObserver = 0 ;
2353   void * jcallback = 0 ;
2354
2355   if (!swig_callbackSignalConnected) {
2356     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2357     return;
2358   } else {
2359     jslotObserver = (void *) slotObserver;
2360     jcallback = (void *) callback;
2361     swig_callbackSignalConnected(jslotObserver, jcallback);
2362   }
2363 }
2364
2365 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2366   void * jslotObserver = 0 ;
2367   void * jcallback = 0 ;
2368
2369   if (!swig_callbackSignalDisconnected) {
2370     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2371     return;
2372   } else {
2373     jslotObserver = (void *) slotObserver;
2374     jcallback = (void *) callback;
2375     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2376   }
2377 }
2378
2379 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2380   return Dali::Toolkit::Internal::Control::GetControlExtension();
2381 }
2382
2383 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2384   swig_callbackOnStageConnection = callbackOnStageConnection;
2385   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2386   swig_callbackOnChildAdd = callbackOnChildAdd;
2387   swig_callbackOnChildRemove = callbackOnChildRemove;
2388   swig_callbackOnPropertySet = callbackOnPropertySet;
2389   swig_callbackOnSizeSet = callbackOnSizeSet;
2390   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2391   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2392   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2393   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2394   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2395   swig_callbackOnRelayout = callbackOnRelayout;
2396   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2397   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2398   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2399   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2400   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2401   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2402   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2403   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2404   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2405   swig_callbackOnInitialize = callbackOnInitialize;
2406   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2407   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2408   swig_callbackOnStyleChange = callbackOnStyleChange;
2409   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2410   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2411   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2412   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2413   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2414   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2415   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2416   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2417   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2418   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2419   swig_callbackOnPinch = callbackOnPinch;
2420   swig_callbackOnPan = callbackOnPan;
2421   swig_callbackOnTap = callbackOnTap;
2422   swig_callbackOnLongPress = callbackOnLongPress;
2423   swig_callbackSignalConnected = callbackSignalConnected;
2424   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2425 }
2426
2427 void SwigDirector_ViewImpl::swig_init_callbacks() {
2428   swig_callbackOnStageConnection = 0;
2429   swig_callbackOnStageDisconnection = 0;
2430   swig_callbackOnChildAdd = 0;
2431   swig_callbackOnChildRemove = 0;
2432   swig_callbackOnPropertySet = 0;
2433   swig_callbackOnSizeSet = 0;
2434   swig_callbackOnSizeAnimation = 0;
2435   swig_callbackOnTouchEvent = 0;
2436   swig_callbackOnHoverEvent = 0;
2437   swig_callbackOnKeyEvent = 0;
2438   swig_callbackOnWheelEvent = 0;
2439   swig_callbackOnRelayout = 0;
2440   swig_callbackOnSetResizePolicy = 0;
2441   swig_callbackGetNaturalSize = 0;
2442   swig_callbackCalculateChildSize = 0;
2443   swig_callbackGetHeightForWidth = 0;
2444   swig_callbackGetWidthForHeight = 0;
2445   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2446   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2447   swig_callbackOnCalculateRelayoutSize = 0;
2448   swig_callbackOnLayoutNegotiated = 0;
2449   swig_callbackOnInitialize = 0;
2450   swig_callbackOnControlChildAdd = 0;
2451   swig_callbackOnControlChildRemove = 0;
2452   swig_callbackOnStyleChange = 0;
2453   swig_callbackOnAccessibilityActivated = 0;
2454   swig_callbackOnAccessibilityPan = 0;
2455   swig_callbackOnAccessibilityTouch = 0;
2456   swig_callbackOnAccessibilityValueChange = 0;
2457   swig_callbackOnAccessibilityZoom = 0;
2458   swig_callbackOnKeyInputFocusGained = 0;
2459   swig_callbackOnKeyInputFocusLost = 0;
2460   swig_callbackGetNextKeyboardFocusableActor = 0;
2461   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2462   swig_callbackOnKeyboardEnter = 0;
2463   swig_callbackOnPinch = 0;
2464   swig_callbackOnPan = 0;
2465   swig_callbackOnTap = 0;
2466   swig_callbackOnLongPress = 0;
2467   swig_callbackSignalConnected = 0;
2468   swig_callbackSignalDisconnected = 0;
2469 }
2470
2471 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2472   swig_init_callbacks();
2473 }
2474
2475 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2476
2477 }
2478
2479
2480 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2481   unsigned int c_result = SwigValueInit< unsigned int >() ;
2482   unsigned int jresult = 0 ;
2483
2484   if (!swig_callbackGetNumberOfItems) {
2485     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2486   } else {
2487     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2488     c_result = (unsigned int)jresult;
2489   }
2490   return c_result;
2491 }
2492
2493 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2494   Dali::Actor c_result ;
2495   void * jresult = 0 ;
2496   unsigned int jitemId  ;
2497
2498   if (!swig_callbackNewItem) {
2499     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2500   } else {
2501     jitemId = itemId;
2502     jresult = (void *) swig_callbackNewItem(jitemId);
2503     if (!jresult) {
2504       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2505       return c_result;
2506     }
2507     c_result = *(Dali::Actor *)jresult;
2508   }
2509   return c_result;
2510 }
2511
2512 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2513   unsigned int jitemId  ;
2514   void * jactor  ;
2515
2516   if (!swig_callbackItemReleased) {
2517     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2518     return;
2519   } else {
2520     jitemId = itemId;
2521     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2522     swig_callbackItemReleased(jitemId, jactor);
2523   }
2524 }
2525
2526 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2527   return Dali::Toolkit::ItemFactory::GetExtension();
2528 }
2529
2530 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2531   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2532   swig_callbackNewItem = callbackNewItem;
2533   swig_callbackItemReleased = callbackItemReleased;
2534 }
2535
2536 void SwigDirector_ItemFactory::swig_init_callbacks() {
2537   swig_callbackGetNumberOfItems = 0;
2538   swig_callbackNewItem = 0;
2539   swig_callbackItemReleased = 0;
2540 }
2541
2542 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2543   swig_init_callbacks();
2544 }
2545
2546 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2547
2548 }
2549
2550
2551 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2552   Dali::Actor c_result ;
2553   void * jresult = 0 ;
2554   void * jcurrent  ;
2555   void * jproposed  ;
2556   int jdirection  ;
2557
2558   if (!swig_callbackGetNextFocusableActor) {
2559     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2560   } else {
2561     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2562     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2563     jdirection = (int)direction;
2564     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2565     if (!jresult) {
2566       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2567       return c_result;
2568     }
2569     c_result = *(Dali::Actor *)jresult;
2570   }
2571   return c_result;
2572 }
2573
2574 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2575   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2576 }
2577
2578 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2579   swig_callbackGetNextFocusableActor = 0;
2580 }
2581
2582
2583 #ifdef __cplusplus
2584 extern "C" {
2585 #endif
2586
2587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2588   void * jresult ;
2589   floatp *result = 0 ;
2590
2591   {
2592     try {
2593       result = (floatp *)new_floatp();
2594     } catch (std::out_of_range& e) {
2595       {
2596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2597       };
2598     } catch (std::exception& e) {
2599       {
2600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2601       };
2602     } catch (DaliException e) {
2603       {
2604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2605       };
2606     } catch (...) {
2607       {
2608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2609       };
2610     }
2611   }
2612   jresult = (void *)result;
2613   return jresult;
2614 }
2615
2616
2617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2618   floatp *arg1 = (floatp *) 0 ;
2619
2620   arg1 = (floatp *)jarg1;
2621   {
2622     try {
2623       delete_floatp(arg1);
2624     } catch (std::out_of_range& e) {
2625       {
2626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2627       };
2628     } catch (std::exception& e) {
2629       {
2630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2631       };
2632     } catch (Dali::DaliException e) {
2633       {
2634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2635       };
2636     } catch (...) {
2637       {
2638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2639       };
2640     }
2641   }
2642
2643 }
2644
2645
2646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2647   floatp *arg1 = (floatp *) 0 ;
2648   float arg2 ;
2649
2650   arg1 = (floatp *)jarg1;
2651   arg2 = (float)jarg2;
2652   {
2653     try {
2654       floatp_assign(arg1,arg2);
2655     } catch (std::out_of_range& e) {
2656       {
2657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2658       };
2659     } catch (std::exception& e) {
2660       {
2661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2662       };
2663     } catch (Dali::DaliException e) {
2664       {
2665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2666       };
2667     } catch (...) {
2668       {
2669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2670       };
2671     }
2672   }
2673
2674 }
2675
2676
2677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2678   float jresult ;
2679   floatp *arg1 = (floatp *) 0 ;
2680   float result;
2681
2682   arg1 = (floatp *)jarg1;
2683   {
2684     try {
2685       result = (float)floatp_value(arg1);
2686     } catch (std::out_of_range& e) {
2687       {
2688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2689       };
2690     } catch (std::exception& e) {
2691       {
2692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2693       };
2694     } catch (DaliException e) {
2695       {
2696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2697       };
2698     } catch (...) {
2699       {
2700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2701       };
2702     }
2703   }
2704   jresult = result;
2705   return jresult;
2706 }
2707
2708
2709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2710   void * jresult ;
2711   floatp *arg1 = (floatp *) 0 ;
2712   float *result = 0 ;
2713
2714   arg1 = (floatp *)jarg1;
2715   {
2716     try {
2717       result = (float *)floatp_cast(arg1);
2718     } catch (std::out_of_range& e) {
2719       {
2720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2721       };
2722     } catch (std::exception& e) {
2723       {
2724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2725       };
2726     } catch (Dali::DaliException e) {
2727       {
2728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2729       };
2730     } catch (...) {
2731       {
2732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2733       };
2734     }
2735   }
2736
2737   jresult = (void *)result;
2738   return jresult;
2739 }
2740
2741
2742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2743   void * jresult ;
2744   float *arg1 = (float *) 0 ;
2745   floatp *result = 0 ;
2746
2747   arg1 = (float *)jarg1;
2748   {
2749     try {
2750       result = (floatp *)floatp_frompointer(arg1);
2751     } catch (std::out_of_range& e) {
2752       {
2753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2754       };
2755     } catch (std::exception& e) {
2756       {
2757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2758       };
2759     } catch (Dali::DaliException e) {
2760       {
2761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2762       };
2763     } catch (...) {
2764       {
2765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2766       };
2767     }
2768   }
2769
2770   jresult = (void *)result;
2771   return jresult;
2772 }
2773
2774
2775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2776   void * jresult ;
2777   intp *result = 0 ;
2778
2779   {
2780     try {
2781       result = (intp *)new_intp();
2782     } catch (std::out_of_range& e) {
2783       {
2784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2785       };
2786     } catch (std::exception& e) {
2787       {
2788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2789       };
2790     } catch (Dali::DaliException e) {
2791       {
2792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2793       };
2794     } catch (...) {
2795       {
2796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2797       };
2798     }
2799   }
2800
2801   jresult = (void *)result;
2802   return jresult;
2803 }
2804
2805
2806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2807   intp *arg1 = (intp *) 0 ;
2808
2809   arg1 = (intp *)jarg1;
2810   {
2811     try {
2812       delete_intp(arg1);
2813     } catch (std::out_of_range& e) {
2814       {
2815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2816       };
2817     } catch (std::exception& e) {
2818       {
2819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2820       };
2821     } catch (Dali::DaliException e) {
2822       {
2823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2824       };
2825     } catch (...) {
2826       {
2827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2828       };
2829     }
2830   }
2831
2832 }
2833
2834
2835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2836   intp *arg1 = (intp *) 0 ;
2837   int arg2 ;
2838
2839   arg1 = (intp *)jarg1;
2840   arg2 = (int)jarg2;
2841   {
2842     try {
2843       intp_assign(arg1,arg2);
2844     } catch (std::out_of_range& e) {
2845       {
2846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2847       };
2848     } catch (std::exception& e) {
2849       {
2850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2851       };
2852     } catch (Dali::DaliException e) {
2853       {
2854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2855       };
2856     } catch (...) {
2857       {
2858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2859       };
2860     }
2861   }
2862
2863 }
2864
2865
2866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2867   int jresult ;
2868   intp *arg1 = (intp *) 0 ;
2869   int result;
2870
2871   arg1 = (intp *)jarg1;
2872   {
2873     try {
2874       result = (int)intp_value(arg1);
2875     } catch (std::out_of_range& e) {
2876       {
2877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2878       };
2879     } catch (std::exception& e) {
2880       {
2881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2882       };
2883     } catch (Dali::DaliException e) {
2884       {
2885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2886       };
2887     } catch (...) {
2888       {
2889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2890       };
2891     }
2892   }
2893
2894   jresult = result;
2895   return jresult;
2896 }
2897
2898
2899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2900   void * jresult ;
2901   intp *arg1 = (intp *) 0 ;
2902   int *result = 0 ;
2903
2904   arg1 = (intp *)jarg1;
2905   {
2906     try {
2907       result = (int *)intp_cast(arg1);
2908     } catch (std::out_of_range& e) {
2909       {
2910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2911       };
2912     } catch (std::exception& e) {
2913       {
2914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2915       };
2916     } catch (Dali::DaliException e) {
2917       {
2918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2919       };
2920     } catch (...) {
2921       {
2922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2923       };
2924     }
2925   }
2926
2927   jresult = (void *)result;
2928   return jresult;
2929 }
2930
2931
2932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2933   void * jresult ;
2934   int *arg1 = (int *) 0 ;
2935   intp *result = 0 ;
2936
2937   arg1 = (int *)jarg1;
2938   {
2939     try {
2940       result = (intp *)intp_frompointer(arg1);
2941     } catch (std::out_of_range& e) {
2942       {
2943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2944       };
2945     } catch (std::exception& e) {
2946       {
2947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2948       };
2949     } catch (Dali::DaliException e) {
2950       {
2951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2952       };
2953     } catch (...) {
2954       {
2955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2956       };
2957     }
2958   }
2959
2960   jresult = (void *)result;
2961   return jresult;
2962 }
2963
2964
2965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2966   void * jresult ;
2967   doublep *result = 0 ;
2968
2969   {
2970     try {
2971       result = (doublep *)new_doublep();
2972     } catch (std::out_of_range& e) {
2973       {
2974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2975       };
2976     } catch (std::exception& e) {
2977       {
2978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2979       };
2980     } catch (Dali::DaliException e) {
2981       {
2982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2983       };
2984     } catch (...) {
2985       {
2986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2987       };
2988     }
2989   }
2990
2991   jresult = (void *)result;
2992   return jresult;
2993 }
2994
2995
2996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2997   doublep *arg1 = (doublep *) 0 ;
2998
2999   arg1 = (doublep *)jarg1;
3000   {
3001     try {
3002       delete_doublep(arg1);
3003     } catch (std::out_of_range& e) {
3004       {
3005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3006       };
3007     } catch (std::exception& e) {
3008       {
3009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3010       };
3011     } catch (Dali::DaliException e) {
3012       {
3013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3014       };
3015     } catch (...) {
3016       {
3017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3018       };
3019     }
3020   }
3021
3022 }
3023
3024
3025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3026   doublep *arg1 = (doublep *) 0 ;
3027   double arg2 ;
3028
3029   arg1 = (doublep *)jarg1;
3030   arg2 = (double)jarg2;
3031   {
3032     try {
3033       doublep_assign(arg1,arg2);
3034     } catch (std::out_of_range& e) {
3035       {
3036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3037       };
3038     } catch (std::exception& e) {
3039       {
3040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3041       };
3042     } catch (Dali::DaliException e) {
3043       {
3044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3045       };
3046     } catch (...) {
3047       {
3048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3049       };
3050     }
3051   }
3052
3053 }
3054
3055
3056 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3057   double jresult ;
3058   doublep *arg1 = (doublep *) 0 ;
3059   double result;
3060
3061   arg1 = (doublep *)jarg1;
3062   {
3063     try {
3064       result = (double)doublep_value(arg1);
3065     } catch (std::out_of_range& e) {
3066       {
3067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3068       };
3069     } catch (std::exception& e) {
3070       {
3071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3072       };
3073     } catch (Dali::DaliException e) {
3074       {
3075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3076       };
3077     } catch (...) {
3078       {
3079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3080       };
3081     }
3082   }
3083
3084   jresult = result;
3085   return jresult;
3086 }
3087
3088
3089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3090   void * jresult ;
3091   doublep *arg1 = (doublep *) 0 ;
3092   double *result = 0 ;
3093
3094   arg1 = (doublep *)jarg1;
3095   {
3096     try {
3097       result = (double *)doublep_cast(arg1);
3098     } catch (std::out_of_range& e) {
3099       {
3100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3101       };
3102     } catch (std::exception& e) {
3103       {
3104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3105       };
3106     } catch (Dali::DaliException e) {
3107       {
3108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3109       };
3110     } catch (...) {
3111       {
3112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3113       };
3114     }
3115   }
3116
3117   jresult = (void *)result;
3118   return jresult;
3119 }
3120
3121
3122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3123   void * jresult ;
3124   double *arg1 = (double *) 0 ;
3125   doublep *result = 0 ;
3126
3127   arg1 = (double *)jarg1;
3128   {
3129     try {
3130       result = (doublep *)doublep_frompointer(arg1);
3131     } catch (std::out_of_range& e) {
3132       {
3133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3134       };
3135     } catch (std::exception& e) {
3136       {
3137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3138       };
3139     } catch (Dali::DaliException e) {
3140       {
3141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3142       };
3143     } catch (...) {
3144       {
3145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3146       };
3147     }
3148   }
3149
3150   jresult = (void *)result;
3151   return jresult;
3152 }
3153
3154
3155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3156   void * jresult ;
3157   uintp *result = 0 ;
3158
3159   {
3160     try {
3161       result = (uintp *)new_uintp();
3162     } catch (std::out_of_range& e) {
3163       {
3164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3165       };
3166     } catch (std::exception& e) {
3167       {
3168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3169       };
3170     } catch (Dali::DaliException e) {
3171       {
3172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3173       };
3174     } catch (...) {
3175       {
3176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3177       };
3178     }
3179   }
3180
3181   jresult = (void *)result;
3182   return jresult;
3183 }
3184
3185
3186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3187   uintp *arg1 = (uintp *) 0 ;
3188
3189   arg1 = (uintp *)jarg1;
3190   {
3191     try {
3192       delete_uintp(arg1);
3193     } catch (std::out_of_range& e) {
3194       {
3195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3196       };
3197     } catch (std::exception& e) {
3198       {
3199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3200       };
3201     } catch (Dali::DaliException e) {
3202       {
3203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3204       };
3205     } catch (...) {
3206       {
3207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3208       };
3209     }
3210   }
3211
3212 }
3213
3214
3215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3216   uintp *arg1 = (uintp *) 0 ;
3217   unsigned int arg2 ;
3218
3219   arg1 = (uintp *)jarg1;
3220   arg2 = (unsigned int)jarg2;
3221   {
3222     try {
3223       uintp_assign(arg1,arg2);
3224     } catch (std::out_of_range& e) {
3225       {
3226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3227       };
3228     } catch (std::exception& e) {
3229       {
3230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3231       };
3232     } catch (Dali::DaliException e) {
3233       {
3234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3235       };
3236     } catch (...) {
3237       {
3238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3239       };
3240     }
3241   }
3242
3243 }
3244
3245
3246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3247   unsigned int jresult ;
3248   uintp *arg1 = (uintp *) 0 ;
3249   unsigned int result;
3250
3251   arg1 = (uintp *)jarg1;
3252   {
3253     try {
3254       result = (unsigned int)uintp_value(arg1);
3255     } catch (std::out_of_range& e) {
3256       {
3257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3258       };
3259     } catch (std::exception& e) {
3260       {
3261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3262       };
3263     } catch (Dali::DaliException e) {
3264       {
3265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3266       };
3267     } catch (...) {
3268       {
3269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3270       };
3271     }
3272   }
3273
3274   jresult = result;
3275   return jresult;
3276 }
3277
3278
3279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3280   void * jresult ;
3281   uintp *arg1 = (uintp *) 0 ;
3282   unsigned int *result = 0 ;
3283
3284   arg1 = (uintp *)jarg1;
3285   {
3286     try {
3287       result = (unsigned int *)uintp_cast(arg1);
3288     } catch (std::out_of_range& e) {
3289       {
3290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3291       };
3292     } catch (std::exception& e) {
3293       {
3294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3295       };
3296     } catch (Dali::DaliException e) {
3297       {
3298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3299       };
3300     } catch (...) {
3301       {
3302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3303       };
3304     }
3305   }
3306
3307   jresult = (void *)result;
3308   return jresult;
3309 }
3310
3311
3312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3313   void * jresult ;
3314   unsigned int *arg1 = (unsigned int *) 0 ;
3315   uintp *result = 0 ;
3316
3317   arg1 = (unsigned int *)jarg1;
3318   {
3319     try {
3320       result = (uintp *)uintp_frompointer(arg1);
3321     } catch (std::out_of_range& e) {
3322       {
3323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3324       };
3325     } catch (std::exception& e) {
3326       {
3327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3328       };
3329     } catch (Dali::DaliException e) {
3330       {
3331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3332       };
3333     } catch (...) {
3334       {
3335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3336       };
3337     }
3338   }
3339
3340   jresult = (void *)result;
3341   return jresult;
3342 }
3343
3344
3345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3346   void * jresult ;
3347   ushortp *result = 0 ;
3348
3349   {
3350     try {
3351       result = (ushortp *)new_ushortp();
3352     } catch (std::out_of_range& e) {
3353       {
3354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3355       };
3356     } catch (std::exception& e) {
3357       {
3358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3359       };
3360     } catch (Dali::DaliException e) {
3361       {
3362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3363       };
3364     } catch (...) {
3365       {
3366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3367       };
3368     }
3369   }
3370
3371   jresult = (void *)result;
3372   return jresult;
3373 }
3374
3375
3376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3377   ushortp *arg1 = (ushortp *) 0 ;
3378
3379   arg1 = (ushortp *)jarg1;
3380   {
3381     try {
3382       delete_ushortp(arg1);
3383     } catch (std::out_of_range& e) {
3384       {
3385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3386       };
3387     } catch (std::exception& e) {
3388       {
3389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3390       };
3391     } catch (Dali::DaliException e) {
3392       {
3393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3394       };
3395     } catch (...) {
3396       {
3397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3398       };
3399     }
3400   }
3401
3402 }
3403
3404
3405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3406   ushortp *arg1 = (ushortp *) 0 ;
3407   unsigned short arg2 ;
3408
3409   arg1 = (ushortp *)jarg1;
3410   arg2 = (unsigned short)jarg2;
3411   {
3412     try {
3413       ushortp_assign(arg1,arg2);
3414     } catch (std::out_of_range& e) {
3415       {
3416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3417       };
3418     } catch (std::exception& e) {
3419       {
3420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3421       };
3422     } catch (Dali::DaliException e) {
3423       {
3424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3425       };
3426     } catch (...) {
3427       {
3428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3429       };
3430     }
3431   }
3432
3433 }
3434
3435
3436 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3437   unsigned short jresult ;
3438   ushortp *arg1 = (ushortp *) 0 ;
3439   unsigned short result;
3440
3441   arg1 = (ushortp *)jarg1;
3442   {
3443     try {
3444       result = (unsigned short)ushortp_value(arg1);
3445     } catch (std::out_of_range& e) {
3446       {
3447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3448       };
3449     } catch (std::exception& e) {
3450       {
3451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3452       };
3453     } catch (Dali::DaliException e) {
3454       {
3455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3456       };
3457     } catch (...) {
3458       {
3459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3460       };
3461     }
3462   }
3463
3464   jresult = result;
3465   return jresult;
3466 }
3467
3468
3469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3470   void * jresult ;
3471   ushortp *arg1 = (ushortp *) 0 ;
3472   unsigned short *result = 0 ;
3473
3474   arg1 = (ushortp *)jarg1;
3475   {
3476     try {
3477       result = (unsigned short *)ushortp_cast(arg1);
3478     } catch (std::out_of_range& e) {
3479       {
3480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3481       };
3482     } catch (std::exception& e) {
3483       {
3484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3485       };
3486     } catch (Dali::DaliException e) {
3487       {
3488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3489       };
3490     } catch (...) {
3491       {
3492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3493       };
3494     }
3495   }
3496
3497   jresult = (void *)result;
3498   return jresult;
3499 }
3500
3501
3502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3503   void * jresult ;
3504   unsigned short *arg1 = (unsigned short *) 0 ;
3505   ushortp *result = 0 ;
3506
3507   arg1 = (unsigned short *)jarg1;
3508   {
3509     try {
3510       result = (ushortp *)ushortp_frompointer(arg1);
3511     } catch (std::out_of_range& e) {
3512       {
3513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3514       };
3515     } catch (std::exception& e) {
3516       {
3517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3518       };
3519     } catch (Dali::DaliException e) {
3520       {
3521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3522       };
3523     } catch (...) {
3524       {
3525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3526       };
3527     }
3528   }
3529
3530   jresult = (void *)result;
3531   return jresult;
3532 }
3533
3534
3535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3536   unsigned int jresult ;
3537   int arg1 ;
3538   unsigned int result;
3539
3540   arg1 = (int)jarg1;
3541   {
3542     try {
3543       result = (unsigned int)int_to_uint(arg1);
3544     } catch (std::out_of_range& e) {
3545       {
3546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3547       };
3548     } catch (std::exception& e) {
3549       {
3550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3551       };
3552     } catch (Dali::DaliException e) {
3553       {
3554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3555       };
3556     } catch (...) {
3557       {
3558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3559       };
3560     }
3561   }
3562
3563   jresult = result;
3564   return jresult;
3565 }
3566
3567
3568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3569   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3570
3571   arg1 = (Dali::RefObject *)jarg1;
3572   {
3573     try {
3574       (arg1)->Reference();
3575     } catch (std::out_of_range& e) {
3576       {
3577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3578       };
3579     } catch (std::exception& e) {
3580       {
3581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3582       };
3583     } catch (Dali::DaliException e) {
3584       {
3585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3586       };
3587     } catch (...) {
3588       {
3589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3590       };
3591     }
3592   }
3593
3594 }
3595
3596
3597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3598   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3599
3600   arg1 = (Dali::RefObject *)jarg1;
3601   {
3602     try {
3603       (arg1)->Unreference();
3604     } catch (std::out_of_range& e) {
3605       {
3606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3607       };
3608     } catch (std::exception& e) {
3609       {
3610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3611       };
3612     } catch (Dali::DaliException e) {
3613       {
3614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3615       };
3616     } catch (...) {
3617       {
3618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3619       };
3620     }
3621   }
3622
3623 }
3624
3625
3626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3627   int jresult ;
3628   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3629   int result;
3630
3631   arg1 = (Dali::RefObject *)jarg1;
3632   {
3633     try {
3634       result = (int)(arg1)->ReferenceCount();
3635     } catch (std::out_of_range& e) {
3636       {
3637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3638       };
3639     } catch (std::exception& e) {
3640       {
3641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3642       };
3643     } catch (Dali::DaliException e) {
3644       {
3645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3646       };
3647     } catch (...) {
3648       {
3649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3650       };
3651     }
3652   }
3653
3654   jresult = result;
3655   return jresult;
3656 }
3657
3658
3659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3660   void * jresult ;
3661   Dali::Any *result = 0 ;
3662
3663   {
3664     try {
3665       result = (Dali::Any *)new Dali::Any();
3666     } catch (std::out_of_range& e) {
3667       {
3668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3669       };
3670     } catch (std::exception& e) {
3671       {
3672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3673       };
3674     } catch (Dali::DaliException e) {
3675       {
3676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3677       };
3678     } catch (...) {
3679       {
3680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3681       };
3682     }
3683   }
3684
3685   jresult = (void *)result;
3686   return jresult;
3687 }
3688
3689
3690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3691   Dali::Any *arg1 = (Dali::Any *) 0 ;
3692
3693   arg1 = (Dali::Any *)jarg1;
3694   {
3695     try {
3696       delete arg1;
3697     } catch (std::out_of_range& e) {
3698       {
3699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3700       };
3701     } catch (std::exception& e) {
3702       {
3703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3704       };
3705     } catch (Dali::DaliException e) {
3706       {
3707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3708       };
3709     } catch (...) {
3710       {
3711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3712       };
3713     }
3714   }
3715
3716 }
3717
3718
3719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3720   char *arg1 = (char *) 0 ;
3721
3722   arg1 = (char *)jarg1;
3723   {
3724     try {
3725       Dali::Any::AssertAlways((char const *)arg1);
3726     } catch (std::out_of_range& e) {
3727       {
3728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3729       };
3730     } catch (std::exception& e) {
3731       {
3732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3733       };
3734     } catch (Dali::DaliException e) {
3735       {
3736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3737       };
3738     } catch (...) {
3739       {
3740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3741       };
3742     }
3743   }
3744
3745 }
3746
3747
3748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3749   void * jresult ;
3750   Dali::Any *arg1 = 0 ;
3751   Dali::Any *result = 0 ;
3752
3753   arg1 = (Dali::Any *)jarg1;
3754   if (!arg1) {
3755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3756     return 0;
3757   }
3758   {
3759     try {
3760       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3761     } catch (std::out_of_range& e) {
3762       {
3763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3764       };
3765     } catch (std::exception& e) {
3766       {
3767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3768       };
3769     } catch (Dali::DaliException e) {
3770       {
3771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3772       };
3773     } catch (...) {
3774       {
3775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3776       };
3777     }
3778   }
3779
3780   jresult = (void *)result;
3781   return jresult;
3782 }
3783
3784
3785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3786   void * jresult ;
3787   Dali::Any *arg1 = (Dali::Any *) 0 ;
3788   Dali::Any *arg2 = 0 ;
3789   Dali::Any *result = 0 ;
3790
3791   arg1 = (Dali::Any *)jarg1;
3792   arg2 = (Dali::Any *)jarg2;
3793   if (!arg2) {
3794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3795     return 0;
3796   }
3797   {
3798     try {
3799       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3800     } catch (std::out_of_range& e) {
3801       {
3802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3803       };
3804     } catch (std::exception& e) {
3805       {
3806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3807       };
3808     } catch (Dali::DaliException e) {
3809       {
3810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3811       };
3812     } catch (...) {
3813       {
3814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3815       };
3816     }
3817   }
3818
3819   jresult = (void *)result;
3820   return jresult;
3821 }
3822
3823
3824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3825   void * jresult ;
3826   Dali::Any *arg1 = (Dali::Any *) 0 ;
3827   std::type_info *result = 0 ;
3828
3829   arg1 = (Dali::Any *)jarg1;
3830   {
3831     try {
3832       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3833     } catch (std::out_of_range& e) {
3834       {
3835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3836       };
3837     } catch (std::exception& e) {
3838       {
3839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3840       };
3841     } catch (Dali::DaliException e) {
3842       {
3843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3844       };
3845     } catch (...) {
3846       {
3847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3848       };
3849     }
3850   }
3851
3852   jresult = (void *)result;
3853   return jresult;
3854 }
3855
3856
3857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3858   unsigned int jresult ;
3859   Dali::Any *arg1 = (Dali::Any *) 0 ;
3860   bool result;
3861
3862   arg1 = (Dali::Any *)jarg1;
3863   {
3864     try {
3865       result = (bool)((Dali::Any const *)arg1)->Empty();
3866     } catch (std::out_of_range& e) {
3867       {
3868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3869       };
3870     } catch (std::exception& e) {
3871       {
3872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3873       };
3874     } catch (Dali::DaliException e) {
3875       {
3876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3877       };
3878     } catch (...) {
3879       {
3880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3881       };
3882     }
3883   }
3884
3885   jresult = result;
3886   return jresult;
3887 }
3888
3889
3890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3891   void * jresult ;
3892   std::type_info *arg1 = 0 ;
3893   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3894   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3895   Dali::Any::AnyContainerBase *result = 0 ;
3896
3897   arg1 = (std::type_info *)jarg1;
3898   if (!arg1) {
3899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3900     return 0;
3901   }
3902   arg2 = (Dali::Any::CloneFunc)jarg2;
3903   arg3 = (Dali::Any::DeleteFunc)jarg3;
3904   {
3905     try {
3906       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3907     } catch (std::out_of_range& e) {
3908       {
3909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3910       };
3911     } catch (std::exception& e) {
3912       {
3913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3914       };
3915     } catch (Dali::DaliException e) {
3916       {
3917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3918       };
3919     } catch (...) {
3920       {
3921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3922       };
3923     }
3924   }
3925
3926   jresult = (void *)result;
3927   return jresult;
3928 }
3929
3930
3931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3932   void * jresult ;
3933   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3934   std::type_info *result = 0 ;
3935
3936   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3937   {
3938     try {
3939       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3940     } catch (std::out_of_range& e) {
3941       {
3942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3943       };
3944     } catch (std::exception& e) {
3945       {
3946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3947       };
3948     } catch (Dali::DaliException e) {
3949       {
3950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3951       };
3952     } catch (...) {
3953       {
3954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3955       };
3956     }
3957   }
3958
3959   jresult = (void *)result;
3960   return jresult;
3961 }
3962
3963
3964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3965   void * jresult ;
3966   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3967   ::std::type_info *result = 0 ;
3968
3969   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3970   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3971   jresult = (void *)result;
3972   return jresult;
3973 }
3974
3975
3976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3977   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3978   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3979
3980   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3981   arg2 = (Dali::Any::CloneFunc)jarg2;
3982   if (arg1) (arg1)->mCloneFunc = arg2;
3983 }
3984
3985
3986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3987   void * jresult ;
3988   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3989   Dali::Any::CloneFunc result;
3990
3991   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3992   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3993   jresult = (void *)result;
3994   return jresult;
3995 }
3996
3997
3998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3999   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4000   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4001
4002   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4003   arg2 = (Dali::Any::DeleteFunc)jarg2;
4004   if (arg1) (arg1)->mDeleteFunc = arg2;
4005 }
4006
4007
4008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4009   void * jresult ;
4010   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4011   Dali::Any::DeleteFunc result;
4012
4013   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4014   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4015   jresult = (void *)result;
4016   return jresult;
4017 }
4018
4019
4020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4021   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4022
4023   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4024   {
4025     try {
4026       delete arg1;
4027     } catch (std::out_of_range& e) {
4028       {
4029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4030       };
4031     } catch (std::exception& e) {
4032       {
4033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4034       };
4035     } catch (Dali::DaliException e) {
4036       {
4037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4038       };
4039     } catch (...) {
4040       {
4041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4042       };
4043     }
4044   }
4045
4046 }
4047
4048
4049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4050   Dali::Any *arg1 = (Dali::Any *) 0 ;
4051   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4052
4053   arg1 = (Dali::Any *)jarg1;
4054   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4055   if (arg1) (arg1)->mContainer = arg2;
4056 }
4057
4058
4059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4060   void * jresult ;
4061   Dali::Any *arg1 = (Dali::Any *) 0 ;
4062   Dali::Any::AnyContainerBase *result = 0 ;
4063
4064   arg1 = (Dali::Any *)jarg1;
4065   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4066   jresult = (void *)result;
4067   return jresult;
4068 }
4069
4070
4071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4072   char *arg1 = (char *) 0 ;
4073   char *arg2 = (char *) 0 ;
4074
4075   arg1 = (char *)jarg1;
4076   arg2 = (char *)jarg2;
4077   {
4078     try {
4079       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4080     } catch (std::out_of_range& e) {
4081       {
4082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4083       };
4084     } catch (std::exception& e) {
4085       {
4086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4087       };
4088     } catch (Dali::DaliException e) {
4089       {
4090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4091       };
4092     } catch (...) {
4093       {
4094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4095       };
4096     }
4097   }
4098
4099 }
4100
4101
4102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4103   void * jresult ;
4104   char *arg1 = (char *) 0 ;
4105   char *arg2 = (char *) 0 ;
4106   Dali::DaliException *result = 0 ;
4107
4108   arg1 = (char *)jarg1;
4109   arg2 = (char *)jarg2;
4110   {
4111     try {
4112       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4113     } catch (std::out_of_range& e) {
4114       {
4115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4116       };
4117     } catch (std::exception& e) {
4118       {
4119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4120       };
4121     } catch (Dali::DaliException e) {
4122       {
4123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4124       };
4125     } catch (...) {
4126       {
4127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4128       };
4129     }
4130   }
4131
4132   jresult = (void *)result;
4133   return jresult;
4134 }
4135
4136
4137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4138   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4139   std::string arg2 = std::string(jarg2);
4140
4141   arg1 = (Dali::DaliException *)jarg1;
4142   {
4143     if (!arg2.empty()) {
4144       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4145     } else {
4146       arg1->location = 0;
4147     }
4148   }
4149 }
4150
4151 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4152   char * jresult ;
4153   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4154   char *result = 0 ;
4155
4156   arg1 = (Dali::DaliException *)jarg1;
4157   result = (char *) ((arg1)->location);
4158   jresult = SWIG_csharp_string_callback((const char *)result);
4159   return jresult;
4160 }
4161
4162
4163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4164   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4165   std::string arg2 = std::string(jarg2);
4166
4167   arg1 = (Dali::DaliException *)jarg1;
4168   {
4169     if (!arg2.empty()) {
4170       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4171     } else {
4172       arg1->condition = 0;
4173     }
4174   }
4175 }
4176
4177
4178 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4179   char * jresult ;
4180   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4181   char *result = 0 ;
4182
4183   arg1 = (Dali::DaliException *)jarg1;
4184   result = (char *) ((arg1)->condition);
4185   jresult = SWIG_csharp_string_callback((const char *)result);
4186   return jresult;
4187 }
4188
4189
4190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4191   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4192
4193   arg1 = (Dali::DaliException *)jarg1;
4194   {
4195     try {
4196       delete arg1;
4197     } catch (std::out_of_range& e) {
4198       {
4199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4200       };
4201     } catch (std::exception& e) {
4202       {
4203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4204       };
4205     } catch (Dali::DaliException e) {
4206       {
4207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4208       };
4209     } catch (...) {
4210       {
4211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4212       };
4213     }
4214   }
4215
4216 }
4217
4218
4219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4220   void * jresult ;
4221   Dali::Vector2 *result = 0 ;
4222
4223   {
4224     try {
4225       result = (Dali::Vector2 *)new Dali::Vector2();
4226     } catch (std::out_of_range& e) {
4227       {
4228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4229       };
4230     } catch (std::exception& e) {
4231       {
4232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4233       };
4234     } catch (Dali::DaliException e) {
4235       {
4236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4237       };
4238     } catch (...) {
4239       {
4240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4241       };
4242     }
4243   }
4244
4245   jresult = (void *)result;
4246   return jresult;
4247 }
4248
4249
4250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4251   void * jresult ;
4252   float arg1 ;
4253   float arg2 ;
4254   Dali::Vector2 *result = 0 ;
4255
4256   arg1 = (float)jarg1;
4257   arg2 = (float)jarg2;
4258   {
4259     try {
4260       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4261     } catch (std::out_of_range& e) {
4262       {
4263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4264       };
4265     } catch (std::exception& e) {
4266       {
4267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4268       };
4269     } catch (Dali::DaliException e) {
4270       {
4271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4272       };
4273     } catch (...) {
4274       {
4275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4276       };
4277     }
4278   }
4279
4280   jresult = (void *)result;
4281   return jresult;
4282 }
4283
4284
4285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4286   void * jresult ;
4287   float *arg1 = (float *) 0 ;
4288   Dali::Vector2 *result = 0 ;
4289
4290   arg1 = jarg1;
4291   {
4292     try {
4293       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4294     } catch (std::out_of_range& e) {
4295       {
4296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4297       };
4298     } catch (std::exception& e) {
4299       {
4300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4301       };
4302     } catch (Dali::DaliException e) {
4303       {
4304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4305       };
4306     } catch (...) {
4307       {
4308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4309       };
4310     }
4311   }
4312
4313   jresult = (void *)result;
4314
4315
4316   return jresult;
4317 }
4318
4319
4320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4321   void * jresult ;
4322   Dali::Vector3 *arg1 = 0 ;
4323   Dali::Vector2 *result = 0 ;
4324
4325   arg1 = (Dali::Vector3 *)jarg1;
4326   if (!arg1) {
4327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4328     return 0;
4329   }
4330   {
4331     try {
4332       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4333     } catch (std::out_of_range& e) {
4334       {
4335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4336       };
4337     } catch (std::exception& e) {
4338       {
4339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4340       };
4341     } catch (Dali::DaliException e) {
4342       {
4343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4344       };
4345     } catch (...) {
4346       {
4347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4348       };
4349     }
4350   }
4351
4352   jresult = (void *)result;
4353   return jresult;
4354 }
4355
4356
4357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4358   void * jresult ;
4359   Dali::Vector4 *arg1 = 0 ;
4360   Dali::Vector2 *result = 0 ;
4361
4362   arg1 = (Dali::Vector4 *)jarg1;
4363   if (!arg1) {
4364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4365     return 0;
4366   }
4367   {
4368     try {
4369       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4370     } catch (std::out_of_range& e) {
4371       {
4372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4373       };
4374     } catch (std::exception& e) {
4375       {
4376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4377       };
4378     } catch (Dali::DaliException e) {
4379       {
4380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4381       };
4382     } catch (...) {
4383       {
4384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4385       };
4386     }
4387   }
4388
4389   jresult = (void *)result;
4390   return jresult;
4391 }
4392
4393
4394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4395   void * jresult ;
4396   Dali::Vector2 *result = 0 ;
4397
4398   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4399   jresult = (void *)result;
4400   return jresult;
4401 }
4402
4403
4404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4405   void * jresult ;
4406   Dali::Vector2 *result = 0 ;
4407
4408   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4409   jresult = (void *)result;
4410   return jresult;
4411 }
4412
4413
4414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4415   void * jresult ;
4416   Dali::Vector2 *result = 0 ;
4417
4418   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4419   jresult = (void *)result;
4420   return jresult;
4421 }
4422
4423
4424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4425   void * jresult ;
4426   Dali::Vector2 *result = 0 ;
4427
4428   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4429   jresult = (void *)result;
4430   return jresult;
4431 }
4432
4433
4434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4435   void * jresult ;
4436   Dali::Vector2 *result = 0 ;
4437
4438   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4439   jresult = (void *)result;
4440   return jresult;
4441 }
4442
4443
4444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4445   void * jresult ;
4446   Dali::Vector2 *result = 0 ;
4447
4448   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4449   jresult = (void *)result;
4450   return jresult;
4451 }
4452
4453
4454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4455   void * jresult ;
4456   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4457   float *arg2 = (float *) 0 ;
4458   Dali::Vector2 *result = 0 ;
4459
4460   arg1 = (Dali::Vector2 *)jarg1;
4461   arg2 = jarg2;
4462   {
4463     try {
4464       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4465     } catch (std::out_of_range& e) {
4466       {
4467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4468       };
4469     } catch (std::exception& e) {
4470       {
4471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4472       };
4473     } catch (Dali::DaliException e) {
4474       {
4475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4476       };
4477     } catch (...) {
4478       {
4479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4480       };
4481     }
4482   }
4483
4484   jresult = (void *)result;
4485
4486
4487   return jresult;
4488 }
4489
4490
4491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4492   void * jresult ;
4493   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4494   Dali::Vector3 *arg2 = 0 ;
4495   Dali::Vector2 *result = 0 ;
4496
4497   arg1 = (Dali::Vector2 *)jarg1;
4498   arg2 = (Dali::Vector3 *)jarg2;
4499   if (!arg2) {
4500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4501     return 0;
4502   }
4503   {
4504     try {
4505       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4506     } catch (std::out_of_range& e) {
4507       {
4508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4509       };
4510     } catch (std::exception& e) {
4511       {
4512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4513       };
4514     } catch (Dali::DaliException e) {
4515       {
4516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4517       };
4518     } catch (...) {
4519       {
4520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4521       };
4522     }
4523   }
4524
4525   jresult = (void *)result;
4526   return jresult;
4527 }
4528
4529
4530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4531   void * jresult ;
4532   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4533   Dali::Vector4 *arg2 = 0 ;
4534   Dali::Vector2 *result = 0 ;
4535
4536   arg1 = (Dali::Vector2 *)jarg1;
4537   arg2 = (Dali::Vector4 *)jarg2;
4538   if (!arg2) {
4539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4540     return 0;
4541   }
4542   {
4543     try {
4544       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4545     } catch (std::out_of_range& e) {
4546       {
4547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4548       };
4549     } catch (std::exception& e) {
4550       {
4551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4552       };
4553     } catch (Dali::DaliException e) {
4554       {
4555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4556       };
4557     } catch (...) {
4558       {
4559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4560       };
4561     }
4562   }
4563
4564   jresult = (void *)result;
4565   return jresult;
4566 }
4567
4568
4569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4570   void * jresult ;
4571   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4572   Dali::Vector2 *arg2 = 0 ;
4573   Dali::Vector2 result;
4574
4575   arg1 = (Dali::Vector2 *)jarg1;
4576   arg2 = (Dali::Vector2 *)jarg2;
4577   if (!arg2) {
4578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4579     return 0;
4580   }
4581   {
4582     try {
4583       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4584     } catch (std::out_of_range& e) {
4585       {
4586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4587       };
4588     } catch (std::exception& e) {
4589       {
4590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4591       };
4592     } catch (Dali::DaliException e) {
4593       {
4594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4595       };
4596     } catch (...) {
4597       {
4598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4599       };
4600     }
4601   }
4602
4603   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4604   return jresult;
4605 }
4606
4607
4608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4609   void * jresult ;
4610   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4611   Dali::Vector2 *arg2 = 0 ;
4612   Dali::Vector2 *result = 0 ;
4613
4614   arg1 = (Dali::Vector2 *)jarg1;
4615   arg2 = (Dali::Vector2 *)jarg2;
4616   if (!arg2) {
4617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4618     return 0;
4619   }
4620   {
4621     try {
4622       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4623     } catch (std::out_of_range& e) {
4624       {
4625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4626       };
4627     } catch (std::exception& e) {
4628       {
4629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4630       };
4631     } catch (Dali::DaliException e) {
4632       {
4633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4634       };
4635     } catch (...) {
4636       {
4637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4638       };
4639     }
4640   }
4641
4642   jresult = (void *)result;
4643   return jresult;
4644 }
4645
4646
4647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4648   void * jresult ;
4649   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4650   Dali::Vector2 *arg2 = 0 ;
4651   Dali::Vector2 result;
4652
4653   arg1 = (Dali::Vector2 *)jarg1;
4654   arg2 = (Dali::Vector2 *)jarg2;
4655   if (!arg2) {
4656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4657     return 0;
4658   }
4659   {
4660     try {
4661       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4662     } catch (std::out_of_range& e) {
4663       {
4664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4665       };
4666     } catch (std::exception& e) {
4667       {
4668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4669       };
4670     } catch (Dali::DaliException e) {
4671       {
4672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4673       };
4674     } catch (...) {
4675       {
4676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4677       };
4678     }
4679   }
4680
4681   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4682   return jresult;
4683 }
4684
4685
4686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4687   void * jresult ;
4688   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4689   Dali::Vector2 *arg2 = 0 ;
4690   Dali::Vector2 *result = 0 ;
4691
4692   arg1 = (Dali::Vector2 *)jarg1;
4693   arg2 = (Dali::Vector2 *)jarg2;
4694   if (!arg2) {
4695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4696     return 0;
4697   }
4698   {
4699     try {
4700       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4701     } catch (std::out_of_range& e) {
4702       {
4703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4704       };
4705     } catch (std::exception& e) {
4706       {
4707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4708       };
4709     } catch (Dali::DaliException e) {
4710       {
4711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4712       };
4713     } catch (...) {
4714       {
4715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4716       };
4717     }
4718   }
4719
4720   jresult = (void *)result;
4721   return jresult;
4722 }
4723
4724
4725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4726   void * jresult ;
4727   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4728   Dali::Vector2 *arg2 = 0 ;
4729   Dali::Vector2 result;
4730
4731   arg1 = (Dali::Vector2 *)jarg1;
4732   arg2 = (Dali::Vector2 *)jarg2;
4733   if (!arg2) {
4734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4735     return 0;
4736   }
4737   {
4738     try {
4739       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4740     } catch (std::out_of_range& e) {
4741       {
4742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4743       };
4744     } catch (std::exception& e) {
4745       {
4746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4747       };
4748     } catch (Dali::DaliException e) {
4749       {
4750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4751       };
4752     } catch (...) {
4753       {
4754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4755       };
4756     }
4757   }
4758
4759   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4760   return jresult;
4761 }
4762
4763
4764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4765   void * jresult ;
4766   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4767   float arg2 ;
4768   Dali::Vector2 result;
4769
4770   arg1 = (Dali::Vector2 *)jarg1;
4771   arg2 = (float)jarg2;
4772   {
4773     try {
4774       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4775     } catch (std::out_of_range& e) {
4776       {
4777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4778       };
4779     } catch (std::exception& e) {
4780       {
4781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4782       };
4783     } catch (Dali::DaliException e) {
4784       {
4785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4786       };
4787     } catch (...) {
4788       {
4789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4790       };
4791     }
4792   }
4793
4794   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4795   return jresult;
4796 }
4797
4798
4799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4800   void * jresult ;
4801   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4802   Dali::Vector2 *arg2 = 0 ;
4803   Dali::Vector2 *result = 0 ;
4804
4805   arg1 = (Dali::Vector2 *)jarg1;
4806   arg2 = (Dali::Vector2 *)jarg2;
4807   if (!arg2) {
4808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4809     return 0;
4810   }
4811   {
4812     try {
4813       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4814     } catch (std::out_of_range& e) {
4815       {
4816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4817       };
4818     } catch (std::exception& e) {
4819       {
4820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4821       };
4822     } catch (Dali::DaliException e) {
4823       {
4824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4825       };
4826     } catch (...) {
4827       {
4828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4829       };
4830     }
4831   }
4832
4833   jresult = (void *)result;
4834   return jresult;
4835 }
4836
4837
4838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4839   void * jresult ;
4840   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4841   float arg2 ;
4842   Dali::Vector2 *result = 0 ;
4843
4844   arg1 = (Dali::Vector2 *)jarg1;
4845   arg2 = (float)jarg2;
4846   {
4847     try {
4848       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4849     } catch (std::out_of_range& e) {
4850       {
4851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4852       };
4853     } catch (std::exception& e) {
4854       {
4855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4856       };
4857     } catch (Dali::DaliException e) {
4858       {
4859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4860       };
4861     } catch (...) {
4862       {
4863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4864       };
4865     }
4866   }
4867
4868   jresult = (void *)result;
4869   return jresult;
4870 }
4871
4872
4873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4874   void * jresult ;
4875   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4876   Dali::Vector2 *arg2 = 0 ;
4877   Dali::Vector2 result;
4878
4879   arg1 = (Dali::Vector2 *)jarg1;
4880   arg2 = (Dali::Vector2 *)jarg2;
4881   if (!arg2) {
4882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4883     return 0;
4884   }
4885   {
4886     try {
4887       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4888     } catch (std::out_of_range& e) {
4889       {
4890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4891       };
4892     } catch (std::exception& e) {
4893       {
4894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4895       };
4896     } catch (Dali::DaliException e) {
4897       {
4898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4899       };
4900     } catch (...) {
4901       {
4902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4903       };
4904     }
4905   }
4906
4907   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4908   return jresult;
4909 }
4910
4911
4912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4913   void * jresult ;
4914   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4915   float arg2 ;
4916   Dali::Vector2 result;
4917
4918   arg1 = (Dali::Vector2 *)jarg1;
4919   arg2 = (float)jarg2;
4920   {
4921     try {
4922       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4923     } catch (std::out_of_range& e) {
4924       {
4925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4926       };
4927     } catch (std::exception& e) {
4928       {
4929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4930       };
4931     } catch (Dali::DaliException e) {
4932       {
4933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4934       };
4935     } catch (...) {
4936       {
4937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4938       };
4939     }
4940   }
4941
4942   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4943   return jresult;
4944 }
4945
4946
4947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4948   void * jresult ;
4949   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4950   Dali::Vector2 *arg2 = 0 ;
4951   Dali::Vector2 *result = 0 ;
4952
4953   arg1 = (Dali::Vector2 *)jarg1;
4954   arg2 = (Dali::Vector2 *)jarg2;
4955   if (!arg2) {
4956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4957     return 0;
4958   }
4959   {
4960     try {
4961       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4962     } catch (std::out_of_range& e) {
4963       {
4964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4965       };
4966     } catch (std::exception& e) {
4967       {
4968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4969       };
4970     } catch (Dali::DaliException e) {
4971       {
4972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4973       };
4974     } catch (...) {
4975       {
4976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4977       };
4978     }
4979   }
4980
4981   jresult = (void *)result;
4982   return jresult;
4983 }
4984
4985
4986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4987   void * jresult ;
4988   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4989   float arg2 ;
4990   Dali::Vector2 *result = 0 ;
4991
4992   arg1 = (Dali::Vector2 *)jarg1;
4993   arg2 = (float)jarg2;
4994   {
4995     try {
4996       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4997     } catch (std::out_of_range& e) {
4998       {
4999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5000       };
5001     } catch (std::exception& e) {
5002       {
5003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5004       };
5005     } catch (Dali::DaliException e) {
5006       {
5007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5008       };
5009     } catch (...) {
5010       {
5011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5012       };
5013     }
5014   }
5015
5016   jresult = (void *)result;
5017   return jresult;
5018 }
5019
5020
5021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5022   void * jresult ;
5023   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5024   Dali::Vector2 result;
5025
5026   arg1 = (Dali::Vector2 *)jarg1;
5027   {
5028     try {
5029       result = ((Dali::Vector2 const *)arg1)->operator -();
5030     } catch (std::out_of_range& e) {
5031       {
5032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5033       };
5034     } catch (std::exception& e) {
5035       {
5036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5037       };
5038     } catch (Dali::DaliException e) {
5039       {
5040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5041       };
5042     } catch (...) {
5043       {
5044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5045       };
5046     }
5047   }
5048
5049   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5050   return jresult;
5051 }
5052
5053
5054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5055   unsigned int jresult ;
5056   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5057   Dali::Vector2 *arg2 = 0 ;
5058   bool result;
5059
5060   arg1 = (Dali::Vector2 *)jarg1;
5061   arg2 = (Dali::Vector2 *)jarg2;
5062   if (!arg2) {
5063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5064     return 0;
5065   }
5066   {
5067     try {
5068       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5069     } catch (std::out_of_range& e) {
5070       {
5071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5072       };
5073     } catch (std::exception& e) {
5074       {
5075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5076       };
5077     } catch (Dali::DaliException e) {
5078       {
5079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5080       };
5081     } catch (...) {
5082       {
5083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5084       };
5085     }
5086   }
5087
5088   jresult = result;
5089   return jresult;
5090 }
5091
5092
5093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5094   unsigned int jresult ;
5095   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5096   Dali::Vector2 *arg2 = 0 ;
5097   bool result;
5098
5099   arg1 = (Dali::Vector2 *)jarg1;
5100   arg2 = (Dali::Vector2 *)jarg2;
5101   if (!arg2) {
5102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5103     return 0;
5104   }
5105   {
5106     try {
5107       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5108     } catch (std::out_of_range& e) {
5109       {
5110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5111       };
5112     } catch (std::exception& e) {
5113       {
5114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5115       };
5116     } catch (Dali::DaliException e) {
5117       {
5118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5119       };
5120     } catch (...) {
5121       {
5122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5123       };
5124     }
5125   }
5126
5127   jresult = result;
5128   return jresult;
5129 }
5130
5131
5132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5133   float jresult ;
5134   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5135   unsigned int arg2 ;
5136   float *result = 0 ;
5137
5138   arg1 = (Dali::Vector2 *)jarg1;
5139   arg2 = (unsigned int)jarg2;
5140   {
5141     try {
5142       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5143     } catch (std::out_of_range& e) {
5144       {
5145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5146       };
5147     } catch (std::exception& e) {
5148       {
5149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5150       };
5151     } catch (Dali::DaliException e) {
5152       {
5153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5154       };
5155     } catch (...) {
5156       {
5157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5158       };
5159     }
5160   }
5161
5162   jresult = *result;
5163   return jresult;
5164 }
5165
5166
5167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5168   float jresult ;
5169   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5170   float result;
5171
5172   arg1 = (Dali::Vector2 *)jarg1;
5173   {
5174     try {
5175       result = (float)((Dali::Vector2 const *)arg1)->Length();
5176     } catch (std::out_of_range& e) {
5177       {
5178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5179       };
5180     } catch (std::exception& e) {
5181       {
5182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5183       };
5184     } catch (Dali::DaliException e) {
5185       {
5186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5187       };
5188     } catch (...) {
5189       {
5190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5191       };
5192     }
5193   }
5194
5195   jresult = result;
5196   return jresult;
5197 }
5198
5199
5200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5201   float jresult ;
5202   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5203   float result;
5204
5205   arg1 = (Dali::Vector2 *)jarg1;
5206   {
5207     try {
5208       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5209     } catch (std::out_of_range& e) {
5210       {
5211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5212       };
5213     } catch (std::exception& e) {
5214       {
5215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5216       };
5217     } catch (Dali::DaliException e) {
5218       {
5219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5220       };
5221     } catch (...) {
5222       {
5223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5224       };
5225     }
5226   }
5227
5228   jresult = result;
5229   return jresult;
5230 }
5231
5232
5233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5234   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5235
5236   arg1 = (Dali::Vector2 *)jarg1;
5237   {
5238     try {
5239       (arg1)->Normalize();
5240     } catch (std::out_of_range& e) {
5241       {
5242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5243       };
5244     } catch (std::exception& e) {
5245       {
5246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5247       };
5248     } catch (Dali::DaliException e) {
5249       {
5250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5251       };
5252     } catch (...) {
5253       {
5254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5255       };
5256     }
5257   }
5258
5259 }
5260
5261
5262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5263   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5264   Dali::Vector2 *arg2 = 0 ;
5265   Dali::Vector2 *arg3 = 0 ;
5266
5267   arg1 = (Dali::Vector2 *)jarg1;
5268   arg2 = (Dali::Vector2 *)jarg2;
5269   if (!arg2) {
5270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5271     return ;
5272   }
5273   arg3 = (Dali::Vector2 *)jarg3;
5274   if (!arg3) {
5275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5276     return ;
5277   }
5278   {
5279     try {
5280       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5281     } catch (std::out_of_range& e) {
5282       {
5283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5284       };
5285     } catch (std::exception& e) {
5286       {
5287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5288       };
5289     } catch (Dali::DaliException e) {
5290       {
5291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5292       };
5293     } catch (...) {
5294       {
5295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5296       };
5297     }
5298   }
5299
5300 }
5301
5302
5303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5304   void * jresult ;
5305   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5306   float *result = 0 ;
5307
5308   arg1 = (Dali::Vector2 *)jarg1;
5309   {
5310     try {
5311       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5312     } catch (std::out_of_range& e) {
5313       {
5314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5315       };
5316     } catch (std::exception& e) {
5317       {
5318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5319       };
5320     } catch (Dali::DaliException e) {
5321       {
5322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5323       };
5324     } catch (...) {
5325       {
5326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5327       };
5328     }
5329   }
5330
5331   jresult = (void *)result;
5332   return jresult;
5333 }
5334
5335
5336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5337   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5338   float arg2 ;
5339
5340   arg1 = (Dali::Vector2 *)jarg1;
5341   arg2 = (float)jarg2;
5342   if (arg1) (arg1)->x = arg2;
5343 }
5344
5345
5346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5347   float jresult ;
5348   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5349   float result;
5350
5351   arg1 = (Dali::Vector2 *)jarg1;
5352   result = (float) ((arg1)->x);
5353   jresult = result;
5354   return jresult;
5355 }
5356
5357
5358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5359   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5360   float arg2 ;
5361
5362   arg1 = (Dali::Vector2 *)jarg1;
5363   arg2 = (float)jarg2;
5364   if (arg1) (arg1)->width = arg2;
5365 }
5366
5367
5368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5369   float jresult ;
5370   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5371   float result;
5372
5373   arg1 = (Dali::Vector2 *)jarg1;
5374   result = (float) ((arg1)->width);
5375   jresult = result;
5376   return jresult;
5377 }
5378
5379
5380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5381   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5382   float arg2 ;
5383
5384   arg1 = (Dali::Vector2 *)jarg1;
5385   arg2 = (float)jarg2;
5386   if (arg1) (arg1)->y = arg2;
5387 }
5388
5389
5390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5391   float jresult ;
5392   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5393   float result;
5394
5395   arg1 = (Dali::Vector2 *)jarg1;
5396   result = (float) ((arg1)->y);
5397   jresult = result;
5398   return jresult;
5399 }
5400
5401
5402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5403   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5404   float arg2 ;
5405
5406   arg1 = (Dali::Vector2 *)jarg1;
5407   arg2 = (float)jarg2;
5408   if (arg1) (arg1)->height = arg2;
5409 }
5410
5411
5412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5413   float jresult ;
5414   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5415   float result;
5416
5417   arg1 = (Dali::Vector2 *)jarg1;
5418   result = (float) ((arg1)->height);
5419   jresult = result;
5420   return jresult;
5421 }
5422
5423
5424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5425   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5426
5427   arg1 = (Dali::Vector2 *)jarg1;
5428   {
5429     try {
5430       delete arg1;
5431     } catch (std::out_of_range& e) {
5432       {
5433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5434       };
5435     } catch (std::exception& e) {
5436       {
5437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5438       };
5439     } catch (Dali::DaliException e) {
5440       {
5441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5442       };
5443     } catch (...) {
5444       {
5445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5446       };
5447     }
5448   }
5449
5450 }
5451
5452
5453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5454   void * jresult ;
5455   Dali::Vector2 *arg1 = 0 ;
5456   Dali::Vector2 *arg2 = 0 ;
5457   Dali::Vector2 result;
5458
5459   arg1 = (Dali::Vector2 *)jarg1;
5460   if (!arg1) {
5461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5462     return 0;
5463   }
5464   arg2 = (Dali::Vector2 *)jarg2;
5465   if (!arg2) {
5466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5467     return 0;
5468   }
5469   {
5470     try {
5471       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5472     } catch (std::out_of_range& e) {
5473       {
5474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5475       };
5476     } catch (std::exception& e) {
5477       {
5478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5479       };
5480     } catch (Dali::DaliException e) {
5481       {
5482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5483       };
5484     } catch (...) {
5485       {
5486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5487       };
5488     }
5489   }
5490
5491   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5492   return jresult;
5493 }
5494
5495
5496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5497   void * jresult ;
5498   Dali::Vector2 *arg1 = 0 ;
5499   Dali::Vector2 *arg2 = 0 ;
5500   Dali::Vector2 result;
5501
5502   arg1 = (Dali::Vector2 *)jarg1;
5503   if (!arg1) {
5504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5505     return 0;
5506   }
5507   arg2 = (Dali::Vector2 *)jarg2;
5508   if (!arg2) {
5509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5510     return 0;
5511   }
5512   {
5513     try {
5514       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5515     } catch (std::out_of_range& e) {
5516       {
5517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5518       };
5519     } catch (std::exception& e) {
5520       {
5521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5522       };
5523     } catch (Dali::DaliException e) {
5524       {
5525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5526       };
5527     } catch (...) {
5528       {
5529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5530       };
5531     }
5532   }
5533
5534   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5535   return jresult;
5536 }
5537
5538
5539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5540   void * jresult ;
5541   Dali::Vector2 *arg1 = 0 ;
5542   float *arg2 = 0 ;
5543   float *arg3 = 0 ;
5544   float temp2 ;
5545   float temp3 ;
5546   Dali::Vector2 result;
5547
5548   arg1 = (Dali::Vector2 *)jarg1;
5549   if (!arg1) {
5550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5551     return 0;
5552   }
5553   temp2 = (float)jarg2;
5554   arg2 = &temp2;
5555   temp3 = (float)jarg3;
5556   arg3 = &temp3;
5557   {
5558     try {
5559       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5560     } catch (std::out_of_range& e) {
5561       {
5562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5563       };
5564     } catch (std::exception& e) {
5565       {
5566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5567       };
5568     } catch (Dali::DaliException e) {
5569       {
5570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5571       };
5572     } catch (...) {
5573       {
5574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5575       };
5576     }
5577   }
5578
5579   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5580   return jresult;
5581 }
5582
5583
5584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5585   void * jresult ;
5586   Dali::Vector3 *result = 0 ;
5587
5588   {
5589     try {
5590       result = (Dali::Vector3 *)new Dali::Vector3();
5591     } catch (std::out_of_range& e) {
5592       {
5593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5594       };
5595     } catch (std::exception& e) {
5596       {
5597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5598       };
5599     } catch (Dali::DaliException e) {
5600       {
5601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5602       };
5603     } catch (...) {
5604       {
5605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5606       };
5607     }
5608   }
5609
5610   jresult = (void *)result;
5611   return jresult;
5612 }
5613
5614
5615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5616   void * jresult ;
5617   float arg1 ;
5618   float arg2 ;
5619   float arg3 ;
5620   Dali::Vector3 *result = 0 ;
5621
5622   arg1 = (float)jarg1;
5623   arg2 = (float)jarg2;
5624   arg3 = (float)jarg3;
5625   {
5626     try {
5627       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5628     } catch (std::out_of_range& e) {
5629       {
5630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5631       };
5632     } catch (std::exception& e) {
5633       {
5634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5635       };
5636     } catch (Dali::DaliException e) {
5637       {
5638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5639       };
5640     } catch (...) {
5641       {
5642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5643       };
5644     }
5645   }
5646
5647   jresult = (void *)result;
5648   return jresult;
5649 }
5650
5651
5652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5653   void * jresult ;
5654   float *arg1 = (float *) 0 ;
5655   Dali::Vector3 *result = 0 ;
5656
5657   arg1 = jarg1;
5658   {
5659     try {
5660       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5661     } catch (std::out_of_range& e) {
5662       {
5663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5664       };
5665     } catch (std::exception& e) {
5666       {
5667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5668       };
5669     } catch (Dali::DaliException e) {
5670       {
5671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5672       };
5673     } catch (...) {
5674       {
5675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5676       };
5677     }
5678   }
5679
5680   jresult = (void *)result;
5681
5682
5683   return jresult;
5684 }
5685
5686
5687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5688   void * jresult ;
5689   Dali::Vector2 *arg1 = 0 ;
5690   Dali::Vector3 *result = 0 ;
5691
5692   arg1 = (Dali::Vector2 *)jarg1;
5693   if (!arg1) {
5694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5695     return 0;
5696   }
5697   {
5698     try {
5699       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5700     } catch (std::out_of_range& e) {
5701       {
5702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5703       };
5704     } catch (std::exception& e) {
5705       {
5706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5707       };
5708     } catch (Dali::DaliException e) {
5709       {
5710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5711       };
5712     } catch (...) {
5713       {
5714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5715       };
5716     }
5717   }
5718
5719   jresult = (void *)result;
5720   return jresult;
5721 }
5722
5723
5724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5725   void * jresult ;
5726   Dali::Vector4 *arg1 = 0 ;
5727   Dali::Vector3 *result = 0 ;
5728
5729   arg1 = (Dali::Vector4 *)jarg1;
5730   if (!arg1) {
5731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5732     return 0;
5733   }
5734   {
5735     try {
5736       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5737     } catch (std::out_of_range& e) {
5738       {
5739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5740       };
5741     } catch (std::exception& e) {
5742       {
5743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5744       };
5745     } catch (Dali::DaliException e) {
5746       {
5747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5748       };
5749     } catch (...) {
5750       {
5751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5752       };
5753     }
5754   }
5755
5756   jresult = (void *)result;
5757   return jresult;
5758 }
5759
5760
5761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5762   void * jresult ;
5763   Dali::Vector3 *result = 0 ;
5764
5765   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5766   jresult = (void *)result;
5767   return jresult;
5768 }
5769
5770
5771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5772   void * jresult ;
5773   Dali::Vector3 *result = 0 ;
5774
5775   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5776   jresult = (void *)result;
5777   return jresult;
5778 }
5779
5780
5781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5782   void * jresult ;
5783   Dali::Vector3 *result = 0 ;
5784
5785   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5786   jresult = (void *)result;
5787   return jresult;
5788 }
5789
5790
5791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5792   void * jresult ;
5793   Dali::Vector3 *result = 0 ;
5794
5795   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5796   jresult = (void *)result;
5797   return jresult;
5798 }
5799
5800
5801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5802   void * jresult ;
5803   Dali::Vector3 *result = 0 ;
5804
5805   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5806   jresult = (void *)result;
5807   return jresult;
5808 }
5809
5810
5811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5812   void * jresult ;
5813   Dali::Vector3 *result = 0 ;
5814
5815   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5816   jresult = (void *)result;
5817   return jresult;
5818 }
5819
5820
5821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5822   void * jresult ;
5823   Dali::Vector3 *result = 0 ;
5824
5825   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5826   jresult = (void *)result;
5827   return jresult;
5828 }
5829
5830
5831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5832   void * jresult ;
5833   Dali::Vector3 *result = 0 ;
5834
5835   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5836   jresult = (void *)result;
5837   return jresult;
5838 }
5839
5840
5841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5842   void * jresult ;
5843   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5844   float *arg2 = (float *) 0 ;
5845   Dali::Vector3 *result = 0 ;
5846
5847   arg1 = (Dali::Vector3 *)jarg1;
5848   arg2 = jarg2;
5849   {
5850     try {
5851       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5852     } catch (std::out_of_range& e) {
5853       {
5854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5855       };
5856     } catch (std::exception& e) {
5857       {
5858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5859       };
5860     } catch (Dali::DaliException e) {
5861       {
5862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5863       };
5864     } catch (...) {
5865       {
5866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5867       };
5868     }
5869   }
5870
5871   jresult = (void *)result;
5872
5873
5874   return jresult;
5875 }
5876
5877
5878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5879   void * jresult ;
5880   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5881   Dali::Vector2 *arg2 = 0 ;
5882   Dali::Vector3 *result = 0 ;
5883
5884   arg1 = (Dali::Vector3 *)jarg1;
5885   arg2 = (Dali::Vector2 *)jarg2;
5886   if (!arg2) {
5887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5888     return 0;
5889   }
5890   {
5891     try {
5892       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5893     } catch (std::out_of_range& e) {
5894       {
5895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5896       };
5897     } catch (std::exception& e) {
5898       {
5899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5900       };
5901     } catch (Dali::DaliException e) {
5902       {
5903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5904       };
5905     } catch (...) {
5906       {
5907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5908       };
5909     }
5910   }
5911
5912   jresult = (void *)result;
5913   return jresult;
5914 }
5915
5916
5917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5918   void * jresult ;
5919   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5920   Dali::Vector4 *arg2 = 0 ;
5921   Dali::Vector3 *result = 0 ;
5922
5923   arg1 = (Dali::Vector3 *)jarg1;
5924   arg2 = (Dali::Vector4 *)jarg2;
5925   if (!arg2) {
5926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5927     return 0;
5928   }
5929   {
5930     try {
5931       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5932     } catch (std::out_of_range& e) {
5933       {
5934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5935       };
5936     } catch (std::exception& e) {
5937       {
5938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5939       };
5940     } catch (Dali::DaliException e) {
5941       {
5942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5943       };
5944     } catch (...) {
5945       {
5946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5947       };
5948     }
5949   }
5950
5951   jresult = (void *)result;
5952   return jresult;
5953 }
5954
5955
5956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5957   void * jresult ;
5958   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5959   Dali::Vector3 *arg2 = 0 ;
5960   Dali::Vector3 result;
5961
5962   arg1 = (Dali::Vector3 *)jarg1;
5963   arg2 = (Dali::Vector3 *)jarg2;
5964   if (!arg2) {
5965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5966     return 0;
5967   }
5968   {
5969     try {
5970       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5971     } catch (std::out_of_range& e) {
5972       {
5973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5974       };
5975     } catch (std::exception& e) {
5976       {
5977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5978       };
5979     } catch (Dali::DaliException e) {
5980       {
5981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5982       };
5983     } catch (...) {
5984       {
5985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5986       };
5987     }
5988   }
5989
5990   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5991   return jresult;
5992 }
5993
5994
5995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5996   void * jresult ;
5997   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5998   Dali::Vector3 *arg2 = 0 ;
5999   Dali::Vector3 *result = 0 ;
6000
6001   arg1 = (Dali::Vector3 *)jarg1;
6002   arg2 = (Dali::Vector3 *)jarg2;
6003   if (!arg2) {
6004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6005     return 0;
6006   }
6007   {
6008     try {
6009       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6010     } catch (std::out_of_range& e) {
6011       {
6012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6013       };
6014     } catch (std::exception& e) {
6015       {
6016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6017       };
6018     } catch (Dali::DaliException e) {
6019       {
6020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6021       };
6022     } catch (...) {
6023       {
6024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6025       };
6026     }
6027   }
6028
6029   jresult = (void *)result;
6030   return jresult;
6031 }
6032
6033
6034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6035   void * jresult ;
6036   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6037   Dali::Vector3 *arg2 = 0 ;
6038   Dali::Vector3 result;
6039
6040   arg1 = (Dali::Vector3 *)jarg1;
6041   arg2 = (Dali::Vector3 *)jarg2;
6042   if (!arg2) {
6043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6044     return 0;
6045   }
6046   {
6047     try {
6048       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6049     } catch (std::out_of_range& e) {
6050       {
6051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6052       };
6053     } catch (std::exception& e) {
6054       {
6055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6056       };
6057     } catch (Dali::DaliException e) {
6058       {
6059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6060       };
6061     } catch (...) {
6062       {
6063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6064       };
6065     }
6066   }
6067
6068   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6069   return jresult;
6070 }
6071
6072
6073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6074   void * jresult ;
6075   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6076   Dali::Vector3 *arg2 = 0 ;
6077   Dali::Vector3 *result = 0 ;
6078
6079   arg1 = (Dali::Vector3 *)jarg1;
6080   arg2 = (Dali::Vector3 *)jarg2;
6081   if (!arg2) {
6082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6083     return 0;
6084   }
6085   {
6086     try {
6087       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6088     } catch (std::out_of_range& e) {
6089       {
6090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6091       };
6092     } catch (std::exception& e) {
6093       {
6094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6095       };
6096     } catch (Dali::DaliException e) {
6097       {
6098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6099       };
6100     } catch (...) {
6101       {
6102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6103       };
6104     }
6105   }
6106
6107   jresult = (void *)result;
6108   return jresult;
6109 }
6110
6111
6112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6113   void * jresult ;
6114   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6115   Dali::Vector3 *arg2 = 0 ;
6116   Dali::Vector3 result;
6117
6118   arg1 = (Dali::Vector3 *)jarg1;
6119   arg2 = (Dali::Vector3 *)jarg2;
6120   if (!arg2) {
6121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6122     return 0;
6123   }
6124   {
6125     try {
6126       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6127     } catch (std::out_of_range& e) {
6128       {
6129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6130       };
6131     } catch (std::exception& e) {
6132       {
6133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6134       };
6135     } catch (Dali::DaliException e) {
6136       {
6137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6138       };
6139     } catch (...) {
6140       {
6141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6142       };
6143     }
6144   }
6145
6146   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6147   return jresult;
6148 }
6149
6150
6151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6152   void * jresult ;
6153   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6154   float arg2 ;
6155   Dali::Vector3 result;
6156
6157   arg1 = (Dali::Vector3 *)jarg1;
6158   arg2 = (float)jarg2;
6159   {
6160     try {
6161       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6162     } catch (std::out_of_range& e) {
6163       {
6164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6165       };
6166     } catch (std::exception& e) {
6167       {
6168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6169       };
6170     } catch (Dali::DaliException e) {
6171       {
6172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6173       };
6174     } catch (...) {
6175       {
6176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6177       };
6178     }
6179   }
6180
6181   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6182   return jresult;
6183 }
6184
6185
6186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6187   void * jresult ;
6188   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6189   Dali::Vector3 *arg2 = 0 ;
6190   Dali::Vector3 *result = 0 ;
6191
6192   arg1 = (Dali::Vector3 *)jarg1;
6193   arg2 = (Dali::Vector3 *)jarg2;
6194   if (!arg2) {
6195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6196     return 0;
6197   }
6198   {
6199     try {
6200       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6201     } catch (std::out_of_range& e) {
6202       {
6203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6204       };
6205     } catch (std::exception& e) {
6206       {
6207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6208       };
6209     } catch (Dali::DaliException e) {
6210       {
6211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6212       };
6213     } catch (...) {
6214       {
6215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6216       };
6217     }
6218   }
6219
6220   jresult = (void *)result;
6221   return jresult;
6222 }
6223
6224
6225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6226   void * jresult ;
6227   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6228   float arg2 ;
6229   Dali::Vector3 *result = 0 ;
6230
6231   arg1 = (Dali::Vector3 *)jarg1;
6232   arg2 = (float)jarg2;
6233   {
6234     try {
6235       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6236     } catch (std::out_of_range& e) {
6237       {
6238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6239       };
6240     } catch (std::exception& e) {
6241       {
6242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6243       };
6244     } catch (Dali::DaliException e) {
6245       {
6246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6247       };
6248     } catch (...) {
6249       {
6250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6251       };
6252     }
6253   }
6254
6255   jresult = (void *)result;
6256   return jresult;
6257 }
6258
6259
6260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6261   void * jresult ;
6262   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6263   Dali::Quaternion *arg2 = 0 ;
6264   Dali::Vector3 *result = 0 ;
6265
6266   arg1 = (Dali::Vector3 *)jarg1;
6267   arg2 = (Dali::Quaternion *)jarg2;
6268   if (!arg2) {
6269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6270     return 0;
6271   }
6272   {
6273     try {
6274       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6275     } catch (std::out_of_range& e) {
6276       {
6277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6278       };
6279     } catch (std::exception& e) {
6280       {
6281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6282       };
6283     } catch (Dali::DaliException e) {
6284       {
6285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6286       };
6287     } catch (...) {
6288       {
6289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6290       };
6291     }
6292   }
6293
6294   jresult = (void *)result;
6295   return jresult;
6296 }
6297
6298
6299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6300   void * jresult ;
6301   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6302   Dali::Vector3 *arg2 = 0 ;
6303   Dali::Vector3 result;
6304
6305   arg1 = (Dali::Vector3 *)jarg1;
6306   arg2 = (Dali::Vector3 *)jarg2;
6307   if (!arg2) {
6308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6309     return 0;
6310   }
6311   {
6312     try {
6313       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6314     } catch (std::out_of_range& e) {
6315       {
6316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6317       };
6318     } catch (std::exception& e) {
6319       {
6320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6321       };
6322     } catch (Dali::DaliException e) {
6323       {
6324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6325       };
6326     } catch (...) {
6327       {
6328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6329       };
6330     }
6331   }
6332
6333   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6334   return jresult;
6335 }
6336
6337
6338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6339   void * jresult ;
6340   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6341   float arg2 ;
6342   Dali::Vector3 result;
6343
6344   arg1 = (Dali::Vector3 *)jarg1;
6345   arg2 = (float)jarg2;
6346   {
6347     try {
6348       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6349     } catch (std::out_of_range& e) {
6350       {
6351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6352       };
6353     } catch (std::exception& e) {
6354       {
6355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6356       };
6357     } catch (Dali::DaliException e) {
6358       {
6359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6360       };
6361     } catch (...) {
6362       {
6363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6364       };
6365     }
6366   }
6367
6368   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6369   return jresult;
6370 }
6371
6372
6373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6374   void * jresult ;
6375   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6376   Dali::Vector3 *arg2 = 0 ;
6377   Dali::Vector3 *result = 0 ;
6378
6379   arg1 = (Dali::Vector3 *)jarg1;
6380   arg2 = (Dali::Vector3 *)jarg2;
6381   if (!arg2) {
6382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6383     return 0;
6384   }
6385   {
6386     try {
6387       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6388     } catch (std::out_of_range& e) {
6389       {
6390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6391       };
6392     } catch (std::exception& e) {
6393       {
6394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6395       };
6396     } catch (Dali::DaliException e) {
6397       {
6398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6399       };
6400     } catch (...) {
6401       {
6402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6403       };
6404     }
6405   }
6406
6407   jresult = (void *)result;
6408   return jresult;
6409 }
6410
6411
6412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6413   void * jresult ;
6414   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6415   float arg2 ;
6416   Dali::Vector3 *result = 0 ;
6417
6418   arg1 = (Dali::Vector3 *)jarg1;
6419   arg2 = (float)jarg2;
6420   {
6421     try {
6422       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6423     } catch (std::out_of_range& e) {
6424       {
6425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6426       };
6427     } catch (std::exception& e) {
6428       {
6429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6430       };
6431     } catch (Dali::DaliException e) {
6432       {
6433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6434       };
6435     } catch (...) {
6436       {
6437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6438       };
6439     }
6440   }
6441
6442   jresult = (void *)result;
6443   return jresult;
6444 }
6445
6446
6447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6448   void * jresult ;
6449   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6450   Dali::Vector3 result;
6451
6452   arg1 = (Dali::Vector3 *)jarg1;
6453   {
6454     try {
6455       result = ((Dali::Vector3 const *)arg1)->operator -();
6456     } catch (std::out_of_range& e) {
6457       {
6458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6459       };
6460     } catch (std::exception& e) {
6461       {
6462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6463       };
6464     } catch (Dali::DaliException e) {
6465       {
6466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6467       };
6468     } catch (...) {
6469       {
6470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6471       };
6472     }
6473   }
6474
6475   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6476   return jresult;
6477 }
6478
6479
6480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6481   unsigned int jresult ;
6482   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6483   Dali::Vector3 *arg2 = 0 ;
6484   bool result;
6485
6486   arg1 = (Dali::Vector3 *)jarg1;
6487   arg2 = (Dali::Vector3 *)jarg2;
6488   if (!arg2) {
6489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6490     return 0;
6491   }
6492   {
6493     try {
6494       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6495     } catch (std::out_of_range& e) {
6496       {
6497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6498       };
6499     } catch (std::exception& e) {
6500       {
6501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6502       };
6503     } catch (Dali::DaliException e) {
6504       {
6505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6506       };
6507     } catch (...) {
6508       {
6509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6510       };
6511     }
6512   }
6513
6514   jresult = result;
6515   return jresult;
6516 }
6517
6518
6519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6520   unsigned int jresult ;
6521   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6522   Dali::Vector3 *arg2 = 0 ;
6523   bool result;
6524
6525   arg1 = (Dali::Vector3 *)jarg1;
6526   arg2 = (Dali::Vector3 *)jarg2;
6527   if (!arg2) {
6528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6529     return 0;
6530   }
6531   {
6532     try {
6533       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6534     } catch (std::out_of_range& e) {
6535       {
6536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6537       };
6538     } catch (std::exception& e) {
6539       {
6540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6541       };
6542     } catch (Dali::DaliException e) {
6543       {
6544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6545       };
6546     } catch (...) {
6547       {
6548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6549       };
6550     }
6551   }
6552
6553   jresult = result;
6554   return jresult;
6555 }
6556
6557
6558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6559   float jresult ;
6560   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6561   unsigned int arg2 ;
6562   float *result = 0 ;
6563
6564   arg1 = (Dali::Vector3 *)jarg1;
6565   arg2 = (unsigned int)jarg2;
6566   {
6567     try {
6568       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6569     } catch (std::out_of_range& e) {
6570       {
6571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6572       };
6573     } catch (std::exception& e) {
6574       {
6575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6576       };
6577     } catch (Dali::DaliException e) {
6578       {
6579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6580       };
6581     } catch (...) {
6582       {
6583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6584       };
6585     }
6586   }
6587
6588   jresult = *result;
6589   return jresult;
6590 }
6591
6592
6593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6594   float jresult ;
6595   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6596   Dali::Vector3 *arg2 = 0 ;
6597   float result;
6598
6599   arg1 = (Dali::Vector3 *)jarg1;
6600   arg2 = (Dali::Vector3 *)jarg2;
6601   if (!arg2) {
6602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6603     return 0;
6604   }
6605   {
6606     try {
6607       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6608     } catch (std::out_of_range& e) {
6609       {
6610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6611       };
6612     } catch (std::exception& e) {
6613       {
6614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6615       };
6616     } catch (Dali::DaliException e) {
6617       {
6618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6619       };
6620     } catch (...) {
6621       {
6622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6623       };
6624     }
6625   }
6626
6627   jresult = result;
6628   return jresult;
6629 }
6630
6631
6632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6633   void * jresult ;
6634   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6635   Dali::Vector3 *arg2 = 0 ;
6636   Dali::Vector3 result;
6637
6638   arg1 = (Dali::Vector3 *)jarg1;
6639   arg2 = (Dali::Vector3 *)jarg2;
6640   if (!arg2) {
6641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6642     return 0;
6643   }
6644   {
6645     try {
6646       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6647     } catch (std::out_of_range& e) {
6648       {
6649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6650       };
6651     } catch (std::exception& e) {
6652       {
6653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6654       };
6655     } catch (Dali::DaliException e) {
6656       {
6657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6658       };
6659     } catch (...) {
6660       {
6661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6662       };
6663     }
6664   }
6665
6666   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6667   return jresult;
6668 }
6669
6670
6671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6672   float jresult ;
6673   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6674   float result;
6675
6676   arg1 = (Dali::Vector3 *)jarg1;
6677   {
6678     try {
6679       result = (float)((Dali::Vector3 const *)arg1)->Length();
6680     } catch (std::out_of_range& e) {
6681       {
6682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6683       };
6684     } catch (std::exception& e) {
6685       {
6686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6687       };
6688     } catch (Dali::DaliException e) {
6689       {
6690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6691       };
6692     } catch (...) {
6693       {
6694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6695       };
6696     }
6697   }
6698
6699   jresult = result;
6700   return jresult;
6701 }
6702
6703
6704 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6705   float jresult ;
6706   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6707   float result;
6708
6709   arg1 = (Dali::Vector3 *)jarg1;
6710   {
6711     try {
6712       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6713     } catch (std::out_of_range& e) {
6714       {
6715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6716       };
6717     } catch (std::exception& e) {
6718       {
6719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6720       };
6721     } catch (Dali::DaliException e) {
6722       {
6723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6724       };
6725     } catch (...) {
6726       {
6727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6728       };
6729     }
6730   }
6731
6732   jresult = result;
6733   return jresult;
6734 }
6735
6736
6737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6738   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6739
6740   arg1 = (Dali::Vector3 *)jarg1;
6741   {
6742     try {
6743       (arg1)->Normalize();
6744     } catch (std::out_of_range& e) {
6745       {
6746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6747       };
6748     } catch (std::exception& e) {
6749       {
6750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6751       };
6752     } catch (Dali::DaliException e) {
6753       {
6754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6755       };
6756     } catch (...) {
6757       {
6758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6759       };
6760     }
6761   }
6762
6763 }
6764
6765
6766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6767   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6768   Dali::Vector3 *arg2 = 0 ;
6769   Dali::Vector3 *arg3 = 0 ;
6770
6771   arg1 = (Dali::Vector3 *)jarg1;
6772   arg2 = (Dali::Vector3 *)jarg2;
6773   if (!arg2) {
6774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6775     return ;
6776   }
6777   arg3 = (Dali::Vector3 *)jarg3;
6778   if (!arg3) {
6779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6780     return ;
6781   }
6782   {
6783     try {
6784       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6785     } catch (std::out_of_range& e) {
6786       {
6787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6788       };
6789     } catch (std::exception& e) {
6790       {
6791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6792       };
6793     } catch (Dali::DaliException e) {
6794       {
6795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6796       };
6797     } catch (...) {
6798       {
6799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6800       };
6801     }
6802   }
6803
6804 }
6805
6806
6807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6808   void * jresult ;
6809   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6810   float *result = 0 ;
6811
6812   arg1 = (Dali::Vector3 *)jarg1;
6813   {
6814     try {
6815       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6816     } catch (std::out_of_range& e) {
6817       {
6818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6819       };
6820     } catch (std::exception& e) {
6821       {
6822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6823       };
6824     } catch (Dali::DaliException e) {
6825       {
6826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6827       };
6828     } catch (...) {
6829       {
6830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6831       };
6832     }
6833   }
6834
6835   jresult = (void *)result;
6836   return jresult;
6837 }
6838
6839
6840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6841   void * jresult ;
6842   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6843   Dali::Vector2 *result = 0 ;
6844
6845   arg1 = (Dali::Vector3 *)jarg1;
6846   {
6847     try {
6848       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6849     } catch (std::out_of_range& e) {
6850       {
6851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6852       };
6853     } catch (std::exception& e) {
6854       {
6855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6856       };
6857     } catch (Dali::DaliException e) {
6858       {
6859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6860       };
6861     } catch (...) {
6862       {
6863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6864       };
6865     }
6866   }
6867
6868   jresult = (void *)result;
6869   return jresult;
6870 }
6871
6872
6873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6874   void * jresult ;
6875   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6876   Dali::Vector2 *result = 0 ;
6877
6878   arg1 = (Dali::Vector3 *)jarg1;
6879   {
6880     try {
6881       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6882     } catch (std::out_of_range& e) {
6883       {
6884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6885       };
6886     } catch (std::exception& e) {
6887       {
6888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6889       };
6890     } catch (Dali::DaliException e) {
6891       {
6892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6893       };
6894     } catch (...) {
6895       {
6896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6897       };
6898     }
6899   }
6900
6901   jresult = (void *)result;
6902   return jresult;
6903 }
6904
6905
6906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6907   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6908   float arg2 ;
6909
6910   arg1 = (Dali::Vector3 *)jarg1;
6911   arg2 = (float)jarg2;
6912   if (arg1) (arg1)->x = arg2;
6913 }
6914
6915
6916 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6917   float jresult ;
6918   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6919   float result;
6920
6921   arg1 = (Dali::Vector3 *)jarg1;
6922   result = (float) ((arg1)->x);
6923   jresult = result;
6924   return jresult;
6925 }
6926
6927
6928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6929   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6930   float arg2 ;
6931
6932   arg1 = (Dali::Vector3 *)jarg1;
6933   arg2 = (float)jarg2;
6934   if (arg1) (arg1)->width = arg2;
6935 }
6936
6937
6938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6939   float jresult ;
6940   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6941   float result;
6942
6943   arg1 = (Dali::Vector3 *)jarg1;
6944   result = (float) ((arg1)->width);
6945   jresult = result;
6946   return jresult;
6947 }
6948
6949
6950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6951   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6952   float arg2 ;
6953
6954   arg1 = (Dali::Vector3 *)jarg1;
6955   arg2 = (float)jarg2;
6956   if (arg1) (arg1)->r = arg2;
6957 }
6958
6959
6960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6961   float jresult ;
6962   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6963   float result;
6964
6965   arg1 = (Dali::Vector3 *)jarg1;
6966   result = (float) ((arg1)->r);
6967   jresult = result;
6968   return jresult;
6969 }
6970
6971
6972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6973   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6974   float arg2 ;
6975
6976   arg1 = (Dali::Vector3 *)jarg1;
6977   arg2 = (float)jarg2;
6978   if (arg1) (arg1)->y = arg2;
6979 }
6980
6981
6982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6983   float jresult ;
6984   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6985   float result;
6986
6987   arg1 = (Dali::Vector3 *)jarg1;
6988   result = (float) ((arg1)->y);
6989   jresult = result;
6990   return jresult;
6991 }
6992
6993
6994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6995   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6996   float arg2 ;
6997
6998   arg1 = (Dali::Vector3 *)jarg1;
6999   arg2 = (float)jarg2;
7000   if (arg1) (arg1)->height = arg2;
7001 }
7002
7003
7004 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7005   float jresult ;
7006   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7007   float result;
7008
7009   arg1 = (Dali::Vector3 *)jarg1;
7010   result = (float) ((arg1)->height);
7011   jresult = result;
7012   return jresult;
7013 }
7014
7015
7016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7017   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7018   float arg2 ;
7019
7020   arg1 = (Dali::Vector3 *)jarg1;
7021   arg2 = (float)jarg2;
7022   if (arg1) (arg1)->g = arg2;
7023 }
7024
7025
7026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7027   float jresult ;
7028   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7029   float result;
7030
7031   arg1 = (Dali::Vector3 *)jarg1;
7032   result = (float) ((arg1)->g);
7033   jresult = result;
7034   return jresult;
7035 }
7036
7037
7038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7039   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7040   float arg2 ;
7041
7042   arg1 = (Dali::Vector3 *)jarg1;
7043   arg2 = (float)jarg2;
7044   if (arg1) (arg1)->z = arg2;
7045 }
7046
7047
7048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7049   float jresult ;
7050   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7051   float result;
7052
7053   arg1 = (Dali::Vector3 *)jarg1;
7054   result = (float) ((arg1)->z);
7055   jresult = result;
7056   return jresult;
7057 }
7058
7059
7060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7061   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7062   float arg2 ;
7063
7064   arg1 = (Dali::Vector3 *)jarg1;
7065   arg2 = (float)jarg2;
7066   if (arg1) (arg1)->depth = arg2;
7067 }
7068
7069
7070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7071   float jresult ;
7072   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7073   float result;
7074
7075   arg1 = (Dali::Vector3 *)jarg1;
7076   result = (float) ((arg1)->depth);
7077   jresult = result;
7078   return jresult;
7079 }
7080
7081
7082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7083   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7084   float arg2 ;
7085
7086   arg1 = (Dali::Vector3 *)jarg1;
7087   arg2 = (float)jarg2;
7088   if (arg1) (arg1)->b = arg2;
7089 }
7090
7091
7092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7093   float jresult ;
7094   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7095   float result;
7096
7097   arg1 = (Dali::Vector3 *)jarg1;
7098   result = (float) ((arg1)->b);
7099   jresult = result;
7100   return jresult;
7101 }
7102
7103
7104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7105   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7106
7107   arg1 = (Dali::Vector3 *)jarg1;
7108   {
7109     try {
7110       delete arg1;
7111     } catch (std::out_of_range& e) {
7112       {
7113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7114       };
7115     } catch (std::exception& e) {
7116       {
7117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7118       };
7119     } catch (Dali::DaliException e) {
7120       {
7121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7122       };
7123     } catch (...) {
7124       {
7125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7126       };
7127     }
7128   }
7129
7130 }
7131
7132
7133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7134   void * jresult ;
7135   Dali::Vector3 *arg1 = 0 ;
7136   Dali::Vector3 *arg2 = 0 ;
7137   Dali::Vector3 result;
7138
7139   arg1 = (Dali::Vector3 *)jarg1;
7140   if (!arg1) {
7141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7142     return 0;
7143   }
7144   arg2 = (Dali::Vector3 *)jarg2;
7145   if (!arg2) {
7146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7147     return 0;
7148   }
7149   {
7150     try {
7151       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7152     } catch (std::out_of_range& e) {
7153       {
7154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7155       };
7156     } catch (std::exception& e) {
7157       {
7158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7159       };
7160     } catch (Dali::DaliException e) {
7161       {
7162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7163       };
7164     } catch (...) {
7165       {
7166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7167       };
7168     }
7169   }
7170
7171   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7172   return jresult;
7173 }
7174
7175
7176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7177   void * jresult ;
7178   Dali::Vector3 *arg1 = 0 ;
7179   Dali::Vector3 *arg2 = 0 ;
7180   Dali::Vector3 result;
7181
7182   arg1 = (Dali::Vector3 *)jarg1;
7183   if (!arg1) {
7184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7185     return 0;
7186   }
7187   arg2 = (Dali::Vector3 *)jarg2;
7188   if (!arg2) {
7189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7190     return 0;
7191   }
7192   {
7193     try {
7194       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7195     } catch (std::out_of_range& e) {
7196       {
7197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7198       };
7199     } catch (std::exception& e) {
7200       {
7201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7202       };
7203     } catch (Dali::DaliException e) {
7204       {
7205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7206       };
7207     } catch (...) {
7208       {
7209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7210       };
7211     }
7212   }
7213
7214   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7215   return jresult;
7216 }
7217
7218
7219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7220   void * jresult ;
7221   Dali::Vector3 *arg1 = 0 ;
7222   float *arg2 = 0 ;
7223   float *arg3 = 0 ;
7224   float temp2 ;
7225   float temp3 ;
7226   Dali::Vector3 result;
7227
7228   arg1 = (Dali::Vector3 *)jarg1;
7229   if (!arg1) {
7230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7231     return 0;
7232   }
7233   temp2 = (float)jarg2;
7234   arg2 = &temp2;
7235   temp3 = (float)jarg3;
7236   arg3 = &temp3;
7237   {
7238     try {
7239       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7240     } catch (std::out_of_range& e) {
7241       {
7242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7243       };
7244     } catch (std::exception& e) {
7245       {
7246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7247       };
7248     } catch (Dali::DaliException e) {
7249       {
7250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7251       };
7252     } catch (...) {
7253       {
7254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7255       };
7256     }
7257   }
7258
7259   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7260   return jresult;
7261 }
7262
7263
7264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7265   void * jresult ;
7266   Dali::Vector4 *result = 0 ;
7267
7268   {
7269     try {
7270       result = (Dali::Vector4 *)new Dali::Vector4();
7271     } catch (std::out_of_range& e) {
7272       {
7273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7274       };
7275     } catch (std::exception& e) {
7276       {
7277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7278       };
7279     } catch (Dali::DaliException e) {
7280       {
7281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7282       };
7283     } catch (...) {
7284       {
7285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7286       };
7287     }
7288   }
7289
7290   jresult = (void *)result;
7291   return jresult;
7292 }
7293
7294
7295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7296   void * jresult ;
7297   float arg1 ;
7298   float arg2 ;
7299   float arg3 ;
7300   float arg4 ;
7301   Dali::Vector4 *result = 0 ;
7302
7303   arg1 = (float)jarg1;
7304   arg2 = (float)jarg2;
7305   arg3 = (float)jarg3;
7306   arg4 = (float)jarg4;
7307   {
7308     try {
7309       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7310     } catch (std::out_of_range& e) {
7311       {
7312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7313       };
7314     } catch (std::exception& e) {
7315       {
7316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7317       };
7318     } catch (Dali::DaliException e) {
7319       {
7320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7321       };
7322     } catch (...) {
7323       {
7324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7325       };
7326     }
7327   }
7328
7329   jresult = (void *)result;
7330   return jresult;
7331 }
7332
7333
7334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7335   void * jresult ;
7336   float *arg1 = (float *) 0 ;
7337   Dali::Vector4 *result = 0 ;
7338
7339   arg1 = jarg1;
7340   {
7341     try {
7342       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7343     } catch (std::out_of_range& e) {
7344       {
7345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7346       };
7347     } catch (std::exception& e) {
7348       {
7349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7350       };
7351     } catch (Dali::DaliException e) {
7352       {
7353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7354       };
7355     } catch (...) {
7356       {
7357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7358       };
7359     }
7360   }
7361
7362   jresult = (void *)result;
7363
7364
7365   return jresult;
7366 }
7367
7368
7369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7370   void * jresult ;
7371   Dali::Vector2 *arg1 = 0 ;
7372   Dali::Vector4 *result = 0 ;
7373
7374   arg1 = (Dali::Vector2 *)jarg1;
7375   if (!arg1) {
7376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7377     return 0;
7378   }
7379   {
7380     try {
7381       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7382     } catch (std::out_of_range& e) {
7383       {
7384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7385       };
7386     } catch (std::exception& e) {
7387       {
7388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7389       };
7390     } catch (Dali::DaliException e) {
7391       {
7392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7393       };
7394     } catch (...) {
7395       {
7396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7397       };
7398     }
7399   }
7400
7401   jresult = (void *)result;
7402   return jresult;
7403 }
7404
7405
7406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7407   void * jresult ;
7408   Dali::Vector3 *arg1 = 0 ;
7409   Dali::Vector4 *result = 0 ;
7410
7411   arg1 = (Dali::Vector3 *)jarg1;
7412   if (!arg1) {
7413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7414     return 0;
7415   }
7416   {
7417     try {
7418       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7419     } catch (std::out_of_range& e) {
7420       {
7421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7422       };
7423     } catch (std::exception& e) {
7424       {
7425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7426       };
7427     } catch (Dali::DaliException e) {
7428       {
7429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7430       };
7431     } catch (...) {
7432       {
7433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7434       };
7435     }
7436   }
7437
7438   jresult = (void *)result;
7439   return jresult;
7440 }
7441
7442
7443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7444   void * jresult ;
7445   Dali::Vector4 *result = 0 ;
7446
7447   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7448   jresult = (void *)result;
7449   return jresult;
7450 }
7451
7452
7453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7454   void * jresult ;
7455   Dali::Vector4 *result = 0 ;
7456
7457   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7458   jresult = (void *)result;
7459   return jresult;
7460 }
7461
7462
7463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7464   void * jresult ;
7465   Dali::Vector4 *result = 0 ;
7466
7467   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7468   jresult = (void *)result;
7469   return jresult;
7470 }
7471
7472
7473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7474   void * jresult ;
7475   Dali::Vector4 *result = 0 ;
7476
7477   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7478   jresult = (void *)result;
7479   return jresult;
7480 }
7481
7482
7483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7484   void * jresult ;
7485   Dali::Vector4 *result = 0 ;
7486
7487   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7488   jresult = (void *)result;
7489   return jresult;
7490 }
7491
7492
7493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7494   void * jresult ;
7495   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7496   float *arg2 = (float *) 0 ;
7497   Dali::Vector4 *result = 0 ;
7498
7499   arg1 = (Dali::Vector4 *)jarg1;
7500   arg2 = jarg2;
7501   {
7502     try {
7503       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7504     } catch (std::out_of_range& e) {
7505       {
7506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7507       };
7508     } catch (std::exception& e) {
7509       {
7510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7511       };
7512     } catch (Dali::DaliException e) {
7513       {
7514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7515       };
7516     } catch (...) {
7517       {
7518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7519       };
7520     }
7521   }
7522
7523   jresult = (void *)result;
7524
7525
7526   return jresult;
7527 }
7528
7529
7530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7531   void * jresult ;
7532   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7533   Dali::Vector2 *arg2 = 0 ;
7534   Dali::Vector4 *result = 0 ;
7535
7536   arg1 = (Dali::Vector4 *)jarg1;
7537   arg2 = (Dali::Vector2 *)jarg2;
7538   if (!arg2) {
7539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7540     return 0;
7541   }
7542   {
7543     try {
7544       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7545     } catch (std::out_of_range& e) {
7546       {
7547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7548       };
7549     } catch (std::exception& e) {
7550       {
7551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7552       };
7553     } catch (Dali::DaliException e) {
7554       {
7555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7556       };
7557     } catch (...) {
7558       {
7559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7560       };
7561     }
7562   }
7563
7564   jresult = (void *)result;
7565   return jresult;
7566 }
7567
7568
7569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7570   void * jresult ;
7571   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7572   Dali::Vector3 *arg2 = 0 ;
7573   Dali::Vector4 *result = 0 ;
7574
7575   arg1 = (Dali::Vector4 *)jarg1;
7576   arg2 = (Dali::Vector3 *)jarg2;
7577   if (!arg2) {
7578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7579     return 0;
7580   }
7581   {
7582     try {
7583       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7584     } catch (std::out_of_range& e) {
7585       {
7586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7587       };
7588     } catch (std::exception& e) {
7589       {
7590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7591       };
7592     } catch (Dali::DaliException e) {
7593       {
7594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7595       };
7596     } catch (...) {
7597       {
7598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7599       };
7600     }
7601   }
7602
7603   jresult = (void *)result;
7604   return jresult;
7605 }
7606
7607
7608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7609   void * jresult ;
7610   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7611   Dali::Vector4 *arg2 = 0 ;
7612   Dali::Vector4 result;
7613
7614   arg1 = (Dali::Vector4 *)jarg1;
7615   arg2 = (Dali::Vector4 *)jarg2;
7616   if (!arg2) {
7617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7618     return 0;
7619   }
7620   {
7621     try {
7622       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7623     } catch (std::out_of_range& e) {
7624       {
7625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7626       };
7627     } catch (std::exception& e) {
7628       {
7629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7630       };
7631     } catch (Dali::DaliException e) {
7632       {
7633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7634       };
7635     } catch (...) {
7636       {
7637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7638       };
7639     }
7640   }
7641
7642   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7643   return jresult;
7644 }
7645
7646
7647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7648   void * jresult ;
7649   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7650   Dali::Vector4 *arg2 = 0 ;
7651   Dali::Vector4 *result = 0 ;
7652
7653   arg1 = (Dali::Vector4 *)jarg1;
7654   arg2 = (Dali::Vector4 *)jarg2;
7655   if (!arg2) {
7656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7657     return 0;
7658   }
7659   {
7660     try {
7661       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7662     } catch (std::out_of_range& e) {
7663       {
7664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7665       };
7666     } catch (std::exception& e) {
7667       {
7668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7669       };
7670     } catch (Dali::DaliException e) {
7671       {
7672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7673       };
7674     } catch (...) {
7675       {
7676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7677       };
7678     }
7679   }
7680
7681   jresult = (void *)result;
7682   return jresult;
7683 }
7684
7685
7686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7687   void * jresult ;
7688   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7689   Dali::Vector4 *arg2 = 0 ;
7690   Dali::Vector4 result;
7691
7692   arg1 = (Dali::Vector4 *)jarg1;
7693   arg2 = (Dali::Vector4 *)jarg2;
7694   if (!arg2) {
7695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7696     return 0;
7697   }
7698   {
7699     try {
7700       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7701     } catch (std::out_of_range& e) {
7702       {
7703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7704       };
7705     } catch (std::exception& e) {
7706       {
7707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7708       };
7709     } catch (Dali::DaliException e) {
7710       {
7711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7712       };
7713     } catch (...) {
7714       {
7715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7716       };
7717     }
7718   }
7719
7720   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7721   return jresult;
7722 }
7723
7724
7725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7726   void * jresult ;
7727   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7728   Dali::Vector4 *arg2 = 0 ;
7729   Dali::Vector4 *result = 0 ;
7730
7731   arg1 = (Dali::Vector4 *)jarg1;
7732   arg2 = (Dali::Vector4 *)jarg2;
7733   if (!arg2) {
7734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7735     return 0;
7736   }
7737   {
7738     try {
7739       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7740     } catch (std::out_of_range& e) {
7741       {
7742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7743       };
7744     } catch (std::exception& e) {
7745       {
7746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7747       };
7748     } catch (Dali::DaliException e) {
7749       {
7750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7751       };
7752     } catch (...) {
7753       {
7754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7755       };
7756     }
7757   }
7758
7759   jresult = (void *)result;
7760   return jresult;
7761 }
7762
7763
7764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7765   void * jresult ;
7766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7767   Dali::Vector4 *arg2 = 0 ;
7768   Dali::Vector4 result;
7769
7770   arg1 = (Dali::Vector4 *)jarg1;
7771   arg2 = (Dali::Vector4 *)jarg2;
7772   if (!arg2) {
7773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7774     return 0;
7775   }
7776   {
7777     try {
7778       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7779     } catch (std::out_of_range& e) {
7780       {
7781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7782       };
7783     } catch (std::exception& e) {
7784       {
7785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7786       };
7787     } catch (Dali::DaliException e) {
7788       {
7789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7790       };
7791     } catch (...) {
7792       {
7793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7794       };
7795     }
7796   }
7797
7798   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7799   return jresult;
7800 }
7801
7802
7803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7804   void * jresult ;
7805   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7806   float arg2 ;
7807   Dali::Vector4 result;
7808
7809   arg1 = (Dali::Vector4 *)jarg1;
7810   arg2 = (float)jarg2;
7811   {
7812     try {
7813       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7814     } catch (std::out_of_range& e) {
7815       {
7816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7817       };
7818     } catch (std::exception& e) {
7819       {
7820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7821       };
7822     } catch (Dali::DaliException e) {
7823       {
7824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7825       };
7826     } catch (...) {
7827       {
7828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7829       };
7830     }
7831   }
7832
7833   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7834   return jresult;
7835 }
7836
7837
7838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7839   void * jresult ;
7840   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7841   Dali::Vector4 *arg2 = 0 ;
7842   Dali::Vector4 *result = 0 ;
7843
7844   arg1 = (Dali::Vector4 *)jarg1;
7845   arg2 = (Dali::Vector4 *)jarg2;
7846   if (!arg2) {
7847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7848     return 0;
7849   }
7850   {
7851     try {
7852       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7853     } catch (std::out_of_range& e) {
7854       {
7855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7856       };
7857     } catch (std::exception& e) {
7858       {
7859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7860       };
7861     } catch (Dali::DaliException e) {
7862       {
7863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7864       };
7865     } catch (...) {
7866       {
7867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7868       };
7869     }
7870   }
7871
7872   jresult = (void *)result;
7873   return jresult;
7874 }
7875
7876
7877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7878   void * jresult ;
7879   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7880   float arg2 ;
7881   Dali::Vector4 *result = 0 ;
7882
7883   arg1 = (Dali::Vector4 *)jarg1;
7884   arg2 = (float)jarg2;
7885   {
7886     try {
7887       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7888     } catch (std::out_of_range& e) {
7889       {
7890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7891       };
7892     } catch (std::exception& e) {
7893       {
7894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7895       };
7896     } catch (Dali::DaliException e) {
7897       {
7898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7899       };
7900     } catch (...) {
7901       {
7902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7903       };
7904     }
7905   }
7906
7907   jresult = (void *)result;
7908   return jresult;
7909 }
7910
7911
7912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7913   void * jresult ;
7914   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7915   Dali::Vector4 *arg2 = 0 ;
7916   Dali::Vector4 result;
7917
7918   arg1 = (Dali::Vector4 *)jarg1;
7919   arg2 = (Dali::Vector4 *)jarg2;
7920   if (!arg2) {
7921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7922     return 0;
7923   }
7924   {
7925     try {
7926       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7927     } catch (std::out_of_range& e) {
7928       {
7929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7930       };
7931     } catch (std::exception& e) {
7932       {
7933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7934       };
7935     } catch (Dali::DaliException e) {
7936       {
7937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7938       };
7939     } catch (...) {
7940       {
7941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7942       };
7943     }
7944   }
7945
7946   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7947   return jresult;
7948 }
7949
7950
7951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7952   void * jresult ;
7953   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7954   float arg2 ;
7955   Dali::Vector4 result;
7956
7957   arg1 = (Dali::Vector4 *)jarg1;
7958   arg2 = (float)jarg2;
7959   {
7960     try {
7961       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7962     } catch (std::out_of_range& e) {
7963       {
7964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7965       };
7966     } catch (std::exception& e) {
7967       {
7968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7969       };
7970     } catch (Dali::DaliException e) {
7971       {
7972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7973       };
7974     } catch (...) {
7975       {
7976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7977       };
7978     }
7979   }
7980
7981   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7982   return jresult;
7983 }
7984
7985
7986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7987   void * jresult ;
7988   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7989   Dali::Vector4 *arg2 = 0 ;
7990   Dali::Vector4 *result = 0 ;
7991
7992   arg1 = (Dali::Vector4 *)jarg1;
7993   arg2 = (Dali::Vector4 *)jarg2;
7994   if (!arg2) {
7995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7996     return 0;
7997   }
7998   {
7999     try {
8000       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8001     } catch (std::out_of_range& e) {
8002       {
8003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8004       };
8005     } catch (std::exception& e) {
8006       {
8007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8008       };
8009     } catch (Dali::DaliException e) {
8010       {
8011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8012       };
8013     } catch (...) {
8014       {
8015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8016       };
8017     }
8018   }
8019
8020   jresult = (void *)result;
8021   return jresult;
8022 }
8023
8024
8025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8026   void * jresult ;
8027   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8028   float arg2 ;
8029   Dali::Vector4 *result = 0 ;
8030
8031   arg1 = (Dali::Vector4 *)jarg1;
8032   arg2 = (float)jarg2;
8033   {
8034     try {
8035       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8036     } catch (std::out_of_range& e) {
8037       {
8038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8039       };
8040     } catch (std::exception& e) {
8041       {
8042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8043       };
8044     } catch (Dali::DaliException e) {
8045       {
8046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8047       };
8048     } catch (...) {
8049       {
8050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8051       };
8052     }
8053   }
8054
8055   jresult = (void *)result;
8056   return jresult;
8057 }
8058
8059
8060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8061   void * jresult ;
8062   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8063   Dali::Vector4 result;
8064
8065   arg1 = (Dali::Vector4 *)jarg1;
8066   {
8067     try {
8068       result = ((Dali::Vector4 const *)arg1)->operator -();
8069     } catch (std::out_of_range& e) {
8070       {
8071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8072       };
8073     } catch (std::exception& e) {
8074       {
8075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8076       };
8077     } catch (Dali::DaliException e) {
8078       {
8079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8080       };
8081     } catch (...) {
8082       {
8083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8084       };
8085     }
8086   }
8087
8088   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8089   return jresult;
8090 }
8091
8092
8093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8094   unsigned int jresult ;
8095   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8096   Dali::Vector4 *arg2 = 0 ;
8097   bool result;
8098
8099   arg1 = (Dali::Vector4 *)jarg1;
8100   arg2 = (Dali::Vector4 *)jarg2;
8101   if (!arg2) {
8102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8103     return 0;
8104   }
8105   {
8106     try {
8107       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8108     } catch (std::out_of_range& e) {
8109       {
8110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8111       };
8112     } catch (std::exception& e) {
8113       {
8114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8115       };
8116     } catch (Dali::DaliException e) {
8117       {
8118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8119       };
8120     } catch (...) {
8121       {
8122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8123       };
8124     }
8125   }
8126
8127   jresult = result;
8128   return jresult;
8129 }
8130
8131
8132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8133   unsigned int jresult ;
8134   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8135   Dali::Vector4 *arg2 = 0 ;
8136   bool result;
8137
8138   arg1 = (Dali::Vector4 *)jarg1;
8139   arg2 = (Dali::Vector4 *)jarg2;
8140   if (!arg2) {
8141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8142     return 0;
8143   }
8144   {
8145     try {
8146       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8147     } catch (std::out_of_range& e) {
8148       {
8149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8150       };
8151     } catch (std::exception& e) {
8152       {
8153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8154       };
8155     } catch (Dali::DaliException e) {
8156       {
8157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8158       };
8159     } catch (...) {
8160       {
8161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8162       };
8163     }
8164   }
8165
8166   jresult = result;
8167   return jresult;
8168 }
8169
8170
8171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8172   float jresult ;
8173   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8174   unsigned int arg2 ;
8175   float *result = 0 ;
8176
8177   arg1 = (Dali::Vector4 *)jarg1;
8178   arg2 = (unsigned int)jarg2;
8179   {
8180     try {
8181       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8182     } catch (std::out_of_range& e) {
8183       {
8184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8185       };
8186     } catch (std::exception& e) {
8187       {
8188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8189       };
8190     } catch (Dali::DaliException e) {
8191       {
8192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8193       };
8194     } catch (...) {
8195       {
8196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8197       };
8198     }
8199   }
8200
8201   jresult = *result;
8202   return jresult;
8203 }
8204
8205
8206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8207   float jresult ;
8208   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8209   Dali::Vector3 *arg2 = 0 ;
8210   float result;
8211
8212   arg1 = (Dali::Vector4 *)jarg1;
8213   arg2 = (Dali::Vector3 *)jarg2;
8214   if (!arg2) {
8215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8216     return 0;
8217   }
8218   {
8219     try {
8220       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8221     } catch (std::out_of_range& e) {
8222       {
8223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8224       };
8225     } catch (std::exception& e) {
8226       {
8227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8228       };
8229     } catch (Dali::DaliException e) {
8230       {
8231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8232       };
8233     } catch (...) {
8234       {
8235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8236       };
8237     }
8238   }
8239
8240   jresult = result;
8241   return jresult;
8242 }
8243
8244
8245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8246   float jresult ;
8247   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8248   Dali::Vector4 *arg2 = 0 ;
8249   float result;
8250
8251   arg1 = (Dali::Vector4 *)jarg1;
8252   arg2 = (Dali::Vector4 *)jarg2;
8253   if (!arg2) {
8254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8255     return 0;
8256   }
8257   {
8258     try {
8259       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8260     } catch (std::out_of_range& e) {
8261       {
8262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8263       };
8264     } catch (std::exception& e) {
8265       {
8266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8267       };
8268     } catch (Dali::DaliException e) {
8269       {
8270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8271       };
8272     } catch (...) {
8273       {
8274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8275       };
8276     }
8277   }
8278
8279   jresult = result;
8280   return jresult;
8281 }
8282
8283
8284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8285   float jresult ;
8286   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8287   Dali::Vector4 *arg2 = 0 ;
8288   float result;
8289
8290   arg1 = (Dali::Vector4 *)jarg1;
8291   arg2 = (Dali::Vector4 *)jarg2;
8292   if (!arg2) {
8293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8294     return 0;
8295   }
8296   {
8297     try {
8298       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8299     } catch (std::out_of_range& e) {
8300       {
8301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8302       };
8303     } catch (std::exception& e) {
8304       {
8305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8306       };
8307     } catch (Dali::DaliException e) {
8308       {
8309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8310       };
8311     } catch (...) {
8312       {
8313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8314       };
8315     }
8316   }
8317
8318   jresult = result;
8319   return jresult;
8320 }
8321
8322
8323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8324   void * jresult ;
8325   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8326   Dali::Vector4 *arg2 = 0 ;
8327   Dali::Vector4 result;
8328
8329   arg1 = (Dali::Vector4 *)jarg1;
8330   arg2 = (Dali::Vector4 *)jarg2;
8331   if (!arg2) {
8332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8333     return 0;
8334   }
8335   {
8336     try {
8337       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8338     } catch (std::out_of_range& e) {
8339       {
8340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8341       };
8342     } catch (std::exception& e) {
8343       {
8344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8345       };
8346     } catch (Dali::DaliException e) {
8347       {
8348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8349       };
8350     } catch (...) {
8351       {
8352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8353       };
8354     }
8355   }
8356
8357   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8358   return jresult;
8359 }
8360
8361
8362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8363   float jresult ;
8364   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8365   float result;
8366
8367   arg1 = (Dali::Vector4 *)jarg1;
8368   {
8369     try {
8370       result = (float)((Dali::Vector4 const *)arg1)->Length();
8371     } catch (std::out_of_range& e) {
8372       {
8373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8374       };
8375     } catch (std::exception& e) {
8376       {
8377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8378       };
8379     } catch (Dali::DaliException e) {
8380       {
8381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8382       };
8383     } catch (...) {
8384       {
8385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8386       };
8387     }
8388   }
8389
8390   jresult = result;
8391   return jresult;
8392 }
8393
8394
8395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8396   float jresult ;
8397   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8398   float result;
8399
8400   arg1 = (Dali::Vector4 *)jarg1;
8401   {
8402     try {
8403       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8404     } catch (std::out_of_range& e) {
8405       {
8406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8407       };
8408     } catch (std::exception& e) {
8409       {
8410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8411       };
8412     } catch (Dali::DaliException e) {
8413       {
8414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8415       };
8416     } catch (...) {
8417       {
8418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8419       };
8420     }
8421   }
8422
8423   jresult = result;
8424   return jresult;
8425 }
8426
8427
8428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8429   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8430
8431   arg1 = (Dali::Vector4 *)jarg1;
8432   {
8433     try {
8434       (arg1)->Normalize();
8435     } catch (std::out_of_range& e) {
8436       {
8437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8438       };
8439     } catch (std::exception& e) {
8440       {
8441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8442       };
8443     } catch (Dali::DaliException e) {
8444       {
8445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8446       };
8447     } catch (...) {
8448       {
8449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8450       };
8451     }
8452   }
8453
8454 }
8455
8456
8457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8458   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8459   Dali::Vector4 *arg2 = 0 ;
8460   Dali::Vector4 *arg3 = 0 ;
8461
8462   arg1 = (Dali::Vector4 *)jarg1;
8463   arg2 = (Dali::Vector4 *)jarg2;
8464   if (!arg2) {
8465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8466     return ;
8467   }
8468   arg3 = (Dali::Vector4 *)jarg3;
8469   if (!arg3) {
8470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8471     return ;
8472   }
8473   {
8474     try {
8475       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8476     } catch (std::out_of_range& e) {
8477       {
8478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8479       };
8480     } catch (std::exception& e) {
8481       {
8482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8483       };
8484     } catch (Dali::DaliException e) {
8485       {
8486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8487       };
8488     } catch (...) {
8489       {
8490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8491       };
8492     }
8493   }
8494
8495 }
8496
8497
8498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8499   void * jresult ;
8500   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8501   float *result = 0 ;
8502
8503   arg1 = (Dali::Vector4 *)jarg1;
8504   {
8505     try {
8506       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8507     } catch (std::out_of_range& e) {
8508       {
8509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8510       };
8511     } catch (std::exception& e) {
8512       {
8513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8514       };
8515     } catch (Dali::DaliException e) {
8516       {
8517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8518       };
8519     } catch (...) {
8520       {
8521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8522       };
8523     }
8524   }
8525
8526   jresult = (void *)result;
8527   return jresult;
8528 }
8529
8530
8531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8532   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8533   float arg2 ;
8534
8535   arg1 = (Dali::Vector4 *)jarg1;
8536   arg2 = (float)jarg2;
8537   if (arg1) (arg1)->x = arg2;
8538 }
8539
8540
8541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8542   float jresult ;
8543   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8544   float result;
8545
8546   arg1 = (Dali::Vector4 *)jarg1;
8547   result = (float) ((arg1)->x);
8548   jresult = result;
8549   return jresult;
8550 }
8551
8552
8553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8554   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8555   float arg2 ;
8556
8557   arg1 = (Dali::Vector4 *)jarg1;
8558   arg2 = (float)jarg2;
8559   if (arg1) (arg1)->r = arg2;
8560 }
8561
8562
8563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8564   float jresult ;
8565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8566   float result;
8567
8568   arg1 = (Dali::Vector4 *)jarg1;
8569   result = (float) ((arg1)->r);
8570   jresult = result;
8571   return jresult;
8572 }
8573
8574
8575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8577   float arg2 ;
8578
8579   arg1 = (Dali::Vector4 *)jarg1;
8580   arg2 = (float)jarg2;
8581   if (arg1) (arg1)->s = arg2;
8582 }
8583
8584
8585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8586   float jresult ;
8587   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8588   float result;
8589
8590   arg1 = (Dali::Vector4 *)jarg1;
8591   result = (float) ((arg1)->s);
8592   jresult = result;
8593   return jresult;
8594 }
8595
8596
8597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8598   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8599   float arg2 ;
8600
8601   arg1 = (Dali::Vector4 *)jarg1;
8602   arg2 = (float)jarg2;
8603   if (arg1) (arg1)->y = arg2;
8604 }
8605
8606
8607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8608   float jresult ;
8609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8610   float result;
8611
8612   arg1 = (Dali::Vector4 *)jarg1;
8613   result = (float) ((arg1)->y);
8614   jresult = result;
8615   return jresult;
8616 }
8617
8618
8619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8621   float arg2 ;
8622
8623   arg1 = (Dali::Vector4 *)jarg1;
8624   arg2 = (float)jarg2;
8625   if (arg1) (arg1)->g = arg2;
8626 }
8627
8628
8629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8630   float jresult ;
8631   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8632   float result;
8633
8634   arg1 = (Dali::Vector4 *)jarg1;
8635   result = (float) ((arg1)->g);
8636   jresult = result;
8637   return jresult;
8638 }
8639
8640
8641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8643   float arg2 ;
8644
8645   arg1 = (Dali::Vector4 *)jarg1;
8646   arg2 = (float)jarg2;
8647   if (arg1) (arg1)->t = arg2;
8648 }
8649
8650
8651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8652   float jresult ;
8653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8654   float result;
8655
8656   arg1 = (Dali::Vector4 *)jarg1;
8657   result = (float) ((arg1)->t);
8658   jresult = result;
8659   return jresult;
8660 }
8661
8662
8663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8664   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8665   float arg2 ;
8666
8667   arg1 = (Dali::Vector4 *)jarg1;
8668   arg2 = (float)jarg2;
8669   if (arg1) (arg1)->z = arg2;
8670 }
8671
8672
8673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8674   float jresult ;
8675   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8676   float result;
8677
8678   arg1 = (Dali::Vector4 *)jarg1;
8679   result = (float) ((arg1)->z);
8680   jresult = result;
8681   return jresult;
8682 }
8683
8684
8685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8686   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8687   float arg2 ;
8688
8689   arg1 = (Dali::Vector4 *)jarg1;
8690   arg2 = (float)jarg2;
8691   if (arg1) (arg1)->b = arg2;
8692 }
8693
8694
8695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8696   float jresult ;
8697   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8698   float result;
8699
8700   arg1 = (Dali::Vector4 *)jarg1;
8701   result = (float) ((arg1)->b);
8702   jresult = result;
8703   return jresult;
8704 }
8705
8706
8707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8709   float arg2 ;
8710
8711   arg1 = (Dali::Vector4 *)jarg1;
8712   arg2 = (float)jarg2;
8713   if (arg1) (arg1)->p = arg2;
8714 }
8715
8716
8717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8718   float jresult ;
8719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8720   float result;
8721
8722   arg1 = (Dali::Vector4 *)jarg1;
8723   result = (float) ((arg1)->p);
8724   jresult = result;
8725   return jresult;
8726 }
8727
8728
8729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8731   float arg2 ;
8732
8733   arg1 = (Dali::Vector4 *)jarg1;
8734   arg2 = (float)jarg2;
8735   if (arg1) (arg1)->w = arg2;
8736 }
8737
8738
8739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8740   float jresult ;
8741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8742   float result;
8743
8744   arg1 = (Dali::Vector4 *)jarg1;
8745   result = (float) ((arg1)->w);
8746   jresult = result;
8747   return jresult;
8748 }
8749
8750
8751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8753   float arg2 ;
8754
8755   arg1 = (Dali::Vector4 *)jarg1;
8756   arg2 = (float)jarg2;
8757   if (arg1) (arg1)->a = arg2;
8758 }
8759
8760
8761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8762   float jresult ;
8763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8764   float result;
8765
8766   arg1 = (Dali::Vector4 *)jarg1;
8767   result = (float) ((arg1)->a);
8768   jresult = result;
8769   return jresult;
8770 }
8771
8772
8773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8774   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8775   float arg2 ;
8776
8777   arg1 = (Dali::Vector4 *)jarg1;
8778   arg2 = (float)jarg2;
8779   if (arg1) (arg1)->q = arg2;
8780 }
8781
8782
8783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8784   float jresult ;
8785   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8786   float result;
8787
8788   arg1 = (Dali::Vector4 *)jarg1;
8789   result = (float) ((arg1)->q);
8790   jresult = result;
8791   return jresult;
8792 }
8793
8794
8795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8796   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8797
8798   arg1 = (Dali::Vector4 *)jarg1;
8799   {
8800     try {
8801       delete arg1;
8802     } catch (std::out_of_range& e) {
8803       {
8804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8805       };
8806     } catch (std::exception& e) {
8807       {
8808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8809       };
8810     } catch (Dali::DaliException e) {
8811       {
8812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8813       };
8814     } catch (...) {
8815       {
8816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8817       };
8818     }
8819   }
8820
8821 }
8822
8823
8824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8825   void * jresult ;
8826   Dali::Vector4 *arg1 = 0 ;
8827   Dali::Vector4 *arg2 = 0 ;
8828   Dali::Vector4 result;
8829
8830   arg1 = (Dali::Vector4 *)jarg1;
8831   if (!arg1) {
8832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8833     return 0;
8834   }
8835   arg2 = (Dali::Vector4 *)jarg2;
8836   if (!arg2) {
8837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8838     return 0;
8839   }
8840   {
8841     try {
8842       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8843     } catch (std::out_of_range& e) {
8844       {
8845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8846       };
8847     } catch (std::exception& e) {
8848       {
8849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8850       };
8851     } catch (Dali::DaliException e) {
8852       {
8853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8854       };
8855     } catch (...) {
8856       {
8857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8858       };
8859     }
8860   }
8861
8862   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8863   return jresult;
8864 }
8865
8866
8867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8868   void * jresult ;
8869   Dali::Vector4 *arg1 = 0 ;
8870   Dali::Vector4 *arg2 = 0 ;
8871   Dali::Vector4 result;
8872
8873   arg1 = (Dali::Vector4 *)jarg1;
8874   if (!arg1) {
8875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8876     return 0;
8877   }
8878   arg2 = (Dali::Vector4 *)jarg2;
8879   if (!arg2) {
8880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8881     return 0;
8882   }
8883   {
8884     try {
8885       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8886     } catch (std::out_of_range& e) {
8887       {
8888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8889       };
8890     } catch (std::exception& e) {
8891       {
8892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8893       };
8894     } catch (Dali::DaliException e) {
8895       {
8896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8897       };
8898     } catch (...) {
8899       {
8900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8901       };
8902     }
8903   }
8904
8905   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8906   return jresult;
8907 }
8908
8909
8910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8911   void * jresult ;
8912   Dali::Vector4 *arg1 = 0 ;
8913   float *arg2 = 0 ;
8914   float *arg3 = 0 ;
8915   float temp2 ;
8916   float temp3 ;
8917   Dali::Vector4 result;
8918
8919   arg1 = (Dali::Vector4 *)jarg1;
8920   if (!arg1) {
8921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8922     return 0;
8923   }
8924   temp2 = (float)jarg2;
8925   arg2 = &temp2;
8926   temp3 = (float)jarg3;
8927   arg3 = &temp3;
8928   {
8929     try {
8930       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8931     } catch (std::out_of_range& e) {
8932       {
8933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8934       };
8935     } catch (std::exception& e) {
8936       {
8937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8938       };
8939     } catch (Dali::DaliException e) {
8940       {
8941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8942       };
8943     } catch (...) {
8944       {
8945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8946       };
8947     }
8948   }
8949
8950   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8951   return jresult;
8952 }
8953
8954
8955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8956   void * jresult ;
8957   Dali::Uint16Pair *result = 0 ;
8958
8959   {
8960     try {
8961       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8962     } catch (std::out_of_range& e) {
8963       {
8964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8965       };
8966     } catch (std::exception& e) {
8967       {
8968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8969       };
8970     } catch (Dali::DaliException e) {
8971       {
8972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8973       };
8974     } catch (...) {
8975       {
8976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8977       };
8978     }
8979   }
8980
8981   jresult = (void *)result;
8982   return jresult;
8983 }
8984
8985
8986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8987   void * jresult ;
8988   uint32_t arg1 ;
8989   uint32_t arg2 ;
8990   Dali::Uint16Pair *result = 0 ;
8991
8992   arg1 = (uint32_t)jarg1;
8993   arg2 = (uint32_t)jarg2;
8994   {
8995     try {
8996       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8997     } catch (std::out_of_range& e) {
8998       {
8999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9000       };
9001     } catch (std::exception& e) {
9002       {
9003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9004       };
9005     } catch (Dali::DaliException e) {
9006       {
9007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9008       };
9009     } catch (...) {
9010       {
9011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9012       };
9013     }
9014   }
9015
9016   jresult = (void *)result;
9017   return jresult;
9018 }
9019
9020
9021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9022   void * jresult ;
9023   Dali::Uint16Pair *arg1 = 0 ;
9024   Dali::Uint16Pair *result = 0 ;
9025
9026   arg1 = (Dali::Uint16Pair *)jarg1;
9027   if (!arg1) {
9028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9029     return 0;
9030   }
9031   {
9032     try {
9033       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9034     } catch (std::out_of_range& e) {
9035       {
9036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9037       };
9038     } catch (std::exception& e) {
9039       {
9040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9041       };
9042     } catch (Dali::DaliException e) {
9043       {
9044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9045       };
9046     } catch (...) {
9047       {
9048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9049       };
9050     }
9051   }
9052
9053   jresult = (void *)result;
9054   return jresult;
9055 }
9056
9057
9058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9059   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9060   uint16_t arg2 ;
9061
9062   arg1 = (Dali::Uint16Pair *)jarg1;
9063   arg2 = (uint16_t)jarg2;
9064   {
9065     try {
9066       (arg1)->SetWidth(arg2);
9067     } catch (std::out_of_range& e) {
9068       {
9069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9070       };
9071     } catch (std::exception& e) {
9072       {
9073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9074       };
9075     } catch (Dali::DaliException e) {
9076       {
9077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9078       };
9079     } catch (...) {
9080       {
9081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9082       };
9083     }
9084   }
9085
9086 }
9087
9088
9089 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9090   unsigned short jresult ;
9091   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9092   uint16_t result;
9093
9094   arg1 = (Dali::Uint16Pair *)jarg1;
9095   {
9096     try {
9097       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9098     } catch (std::out_of_range& e) {
9099       {
9100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9101       };
9102     } catch (std::exception& e) {
9103       {
9104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9105       };
9106     } catch (Dali::DaliException e) {
9107       {
9108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9109       };
9110     } catch (...) {
9111       {
9112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9113       };
9114     }
9115   }
9116
9117   jresult = result;
9118   return jresult;
9119 }
9120
9121
9122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9123   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9124   uint16_t arg2 ;
9125
9126   arg1 = (Dali::Uint16Pair *)jarg1;
9127   arg2 = (uint16_t)jarg2;
9128   {
9129     try {
9130       (arg1)->SetHeight(arg2);
9131     } catch (std::out_of_range& e) {
9132       {
9133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9134       };
9135     } catch (std::exception& e) {
9136       {
9137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9138       };
9139     } catch (Dali::DaliException e) {
9140       {
9141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9142       };
9143     } catch (...) {
9144       {
9145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9146       };
9147     }
9148   }
9149
9150 }
9151
9152
9153 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9154   unsigned short jresult ;
9155   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9156   uint16_t result;
9157
9158   arg1 = (Dali::Uint16Pair *)jarg1;
9159   {
9160     try {
9161       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9162     } catch (std::out_of_range& e) {
9163       {
9164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9165       };
9166     } catch (std::exception& e) {
9167       {
9168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9169       };
9170     } catch (Dali::DaliException e) {
9171       {
9172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9173       };
9174     } catch (...) {
9175       {
9176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9177       };
9178     }
9179   }
9180
9181   jresult = result;
9182   return jresult;
9183 }
9184
9185
9186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9187   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9188   uint16_t arg2 ;
9189
9190   arg1 = (Dali::Uint16Pair *)jarg1;
9191   arg2 = (uint16_t)jarg2;
9192   {
9193     try {
9194       (arg1)->SetX(arg2);
9195     } catch (std::out_of_range& e) {
9196       {
9197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9198       };
9199     } catch (std::exception& e) {
9200       {
9201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9202       };
9203     } catch (Dali::DaliException e) {
9204       {
9205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9206       };
9207     } catch (...) {
9208       {
9209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9210       };
9211     }
9212   }
9213
9214 }
9215
9216
9217 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9218   unsigned short jresult ;
9219   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9220   uint16_t result;
9221
9222   arg1 = (Dali::Uint16Pair *)jarg1;
9223   {
9224     try {
9225       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9226     } catch (std::out_of_range& e) {
9227       {
9228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9229       };
9230     } catch (std::exception& e) {
9231       {
9232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9233       };
9234     } catch (Dali::DaliException e) {
9235       {
9236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9237       };
9238     } catch (...) {
9239       {
9240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9241       };
9242     }
9243   }
9244
9245   jresult = result;
9246   return jresult;
9247 }
9248
9249
9250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9251   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9252   uint16_t arg2 ;
9253
9254   arg1 = (Dali::Uint16Pair *)jarg1;
9255   arg2 = (uint16_t)jarg2;
9256   {
9257     try {
9258       (arg1)->SetY(arg2);
9259     } catch (std::out_of_range& e) {
9260       {
9261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9262       };
9263     } catch (std::exception& e) {
9264       {
9265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9266       };
9267     } catch (Dali::DaliException e) {
9268       {
9269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9270       };
9271     } catch (...) {
9272       {
9273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9274       };
9275     }
9276   }
9277
9278 }
9279
9280
9281 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9282   unsigned short jresult ;
9283   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9284   uint16_t result;
9285
9286   arg1 = (Dali::Uint16Pair *)jarg1;
9287   {
9288     try {
9289       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9290     } catch (std::out_of_range& e) {
9291       {
9292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9293       };
9294     } catch (std::exception& e) {
9295       {
9296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9297       };
9298     } catch (Dali::DaliException e) {
9299       {
9300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9301       };
9302     } catch (...) {
9303       {
9304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9305       };
9306     }
9307   }
9308
9309   jresult = result;
9310   return jresult;
9311 }
9312
9313
9314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9315   void * jresult ;
9316   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9317   Dali::Uint16Pair *arg2 = 0 ;
9318   Dali::Uint16Pair *result = 0 ;
9319
9320   arg1 = (Dali::Uint16Pair *)jarg1;
9321   arg2 = (Dali::Uint16Pair *)jarg2;
9322   if (!arg2) {
9323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9324     return 0;
9325   }
9326   {
9327     try {
9328       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9329     } catch (std::out_of_range& e) {
9330       {
9331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9332       };
9333     } catch (std::exception& e) {
9334       {
9335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9336       };
9337     } catch (Dali::DaliException e) {
9338       {
9339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9340       };
9341     } catch (...) {
9342       {
9343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9344       };
9345     }
9346   }
9347
9348   jresult = (void *)result;
9349   return jresult;
9350 }
9351
9352
9353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9354   unsigned int jresult ;
9355   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9356   Dali::Uint16Pair *arg2 = 0 ;
9357   bool result;
9358
9359   arg1 = (Dali::Uint16Pair *)jarg1;
9360   arg2 = (Dali::Uint16Pair *)jarg2;
9361   if (!arg2) {
9362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9363     return 0;
9364   }
9365   {
9366     try {
9367       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9368     } catch (std::out_of_range& e) {
9369       {
9370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9371       };
9372     } catch (std::exception& e) {
9373       {
9374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9375       };
9376     } catch (Dali::DaliException e) {
9377       {
9378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9379       };
9380     } catch (...) {
9381       {
9382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9383       };
9384     }
9385   }
9386
9387   jresult = result;
9388   return jresult;
9389 }
9390
9391
9392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9393   unsigned int jresult ;
9394   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9395   Dali::Uint16Pair *arg2 = 0 ;
9396   bool result;
9397
9398   arg1 = (Dali::Uint16Pair *)jarg1;
9399   arg2 = (Dali::Uint16Pair *)jarg2;
9400   if (!arg2) {
9401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9402     return 0;
9403   }
9404   {
9405     try {
9406       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9407     } catch (std::out_of_range& e) {
9408       {
9409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9410       };
9411     } catch (std::exception& e) {
9412       {
9413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9414       };
9415     } catch (Dali::DaliException e) {
9416       {
9417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9418       };
9419     } catch (...) {
9420       {
9421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9422       };
9423     }
9424   }
9425
9426   jresult = result;
9427   return jresult;
9428 }
9429
9430
9431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9432   unsigned int jresult ;
9433   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9434   Dali::Uint16Pair *arg2 = 0 ;
9435   bool result;
9436
9437   arg1 = (Dali::Uint16Pair *)jarg1;
9438   arg2 = (Dali::Uint16Pair *)jarg2;
9439   if (!arg2) {
9440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9441     return 0;
9442   }
9443   {
9444     try {
9445       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9446     } catch (std::out_of_range& e) {
9447       {
9448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9449       };
9450     } catch (std::exception& e) {
9451       {
9452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9453       };
9454     } catch (Dali::DaliException e) {
9455       {
9456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9457       };
9458     } catch (...) {
9459       {
9460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9461       };
9462     }
9463   }
9464
9465   jresult = result;
9466   return jresult;
9467 }
9468
9469
9470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9471   unsigned int jresult ;
9472   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9473   Dali::Uint16Pair *arg2 = 0 ;
9474   bool result;
9475
9476   arg1 = (Dali::Uint16Pair *)jarg1;
9477   arg2 = (Dali::Uint16Pair *)jarg2;
9478   if (!arg2) {
9479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9480     return 0;
9481   }
9482   {
9483     try {
9484       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9485     } catch (std::out_of_range& e) {
9486       {
9487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9488       };
9489     } catch (std::exception& e) {
9490       {
9491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9492       };
9493     } catch (Dali::DaliException e) {
9494       {
9495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9496       };
9497     } catch (...) {
9498       {
9499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9500       };
9501     }
9502   }
9503
9504   jresult = result;
9505   return jresult;
9506 }
9507
9508
9509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9510   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9511
9512   arg1 = (Dali::Uint16Pair *)jarg1;
9513   {
9514     try {
9515       delete arg1;
9516     } catch (std::out_of_range& e) {
9517       {
9518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9519       };
9520     } catch (std::exception& e) {
9521       {
9522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9523       };
9524     } catch (Dali::DaliException e) {
9525       {
9526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9527       };
9528     } catch (...) {
9529       {
9530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9531       };
9532     }
9533   }
9534
9535 }
9536
9537
9538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9539   void * jresult ;
9540   Dali::Degree *result = 0 ;
9541
9542   {
9543     try {
9544       result = (Dali::Degree *)new Dali::Degree();
9545     } catch (std::out_of_range& e) {
9546       {
9547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9548       };
9549     } catch (std::exception& e) {
9550       {
9551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9552       };
9553     } catch (Dali::DaliException e) {
9554       {
9555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9556       };
9557     } catch (...) {
9558       {
9559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9560       };
9561     }
9562   }
9563
9564   jresult = (void *)result;
9565   return jresult;
9566 }
9567
9568
9569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9570   void * jresult ;
9571   float arg1 ;
9572   Dali::Degree *result = 0 ;
9573
9574   arg1 = (float)jarg1;
9575   {
9576     try {
9577       result = (Dali::Degree *)new Dali::Degree(arg1);
9578     } catch (std::out_of_range& e) {
9579       {
9580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9581       };
9582     } catch (std::exception& e) {
9583       {
9584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9585       };
9586     } catch (Dali::DaliException e) {
9587       {
9588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9589       };
9590     } catch (...) {
9591       {
9592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9593       };
9594     }
9595   }
9596
9597   jresult = (void *)result;
9598   return jresult;
9599 }
9600
9601
9602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9603   void * jresult ;
9604   Dali::Radian arg1 ;
9605   Dali::Radian *argp1 ;
9606   Dali::Degree *result = 0 ;
9607
9608   argp1 = (Dali::Radian *)jarg1;
9609   if (!argp1) {
9610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9611     return 0;
9612   }
9613   arg1 = *argp1;
9614   {
9615     try {
9616       result = (Dali::Degree *)new Dali::Degree(arg1);
9617     } catch (std::out_of_range& e) {
9618       {
9619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9620       };
9621     } catch (std::exception& e) {
9622       {
9623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9624       };
9625     } catch (Dali::DaliException e) {
9626       {
9627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9628       };
9629     } catch (...) {
9630       {
9631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9632       };
9633     }
9634   }
9635
9636   jresult = (void *)result;
9637   return jresult;
9638 }
9639
9640
9641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9642   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9643   float arg2 ;
9644
9645   arg1 = (Dali::Degree *)jarg1;
9646   arg2 = (float)jarg2;
9647   if (arg1) (arg1)->degree = arg2;
9648 }
9649
9650
9651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9652   float jresult ;
9653   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9654   float result;
9655
9656   arg1 = (Dali::Degree *)jarg1;
9657   result = (float) ((arg1)->degree);
9658   jresult = result;
9659   return jresult;
9660 }
9661
9662
9663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9664   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9665
9666   arg1 = (Dali::Degree *)jarg1;
9667   {
9668     try {
9669       delete arg1;
9670     } catch (std::out_of_range& e) {
9671       {
9672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9673       };
9674     } catch (std::exception& e) {
9675       {
9676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9677       };
9678     } catch (Dali::DaliException e) {
9679       {
9680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9681       };
9682     } catch (...) {
9683       {
9684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9685       };
9686     }
9687   }
9688
9689 }
9690
9691
9692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9693   void * jresult ;
9694   Dali::Radian *result = 0 ;
9695
9696   result = (Dali::Radian *)&Dali::ANGLE_360;
9697   jresult = (void *)result;
9698   return jresult;
9699 }
9700
9701
9702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9703   void * jresult ;
9704   Dali::Radian *result = 0 ;
9705
9706   result = (Dali::Radian *)&Dali::ANGLE_315;
9707   jresult = (void *)result;
9708   return jresult;
9709 }
9710
9711
9712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9713   void * jresult ;
9714   Dali::Radian *result = 0 ;
9715
9716   result = (Dali::Radian *)&Dali::ANGLE_270;
9717   jresult = (void *)result;
9718   return jresult;
9719 }
9720
9721
9722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9723   void * jresult ;
9724   Dali::Radian *result = 0 ;
9725
9726   result = (Dali::Radian *)&Dali::ANGLE_225;
9727   jresult = (void *)result;
9728   return jresult;
9729 }
9730
9731
9732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9733   void * jresult ;
9734   Dali::Radian *result = 0 ;
9735
9736   result = (Dali::Radian *)&Dali::ANGLE_180;
9737   jresult = (void *)result;
9738   return jresult;
9739 }
9740
9741
9742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9743   void * jresult ;
9744   Dali::Radian *result = 0 ;
9745
9746   result = (Dali::Radian *)&Dali::ANGLE_135;
9747   jresult = (void *)result;
9748   return jresult;
9749 }
9750
9751
9752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9753   void * jresult ;
9754   Dali::Radian *result = 0 ;
9755
9756   result = (Dali::Radian *)&Dali::ANGLE_120;
9757   jresult = (void *)result;
9758   return jresult;
9759 }
9760
9761
9762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9763   void * jresult ;
9764   Dali::Radian *result = 0 ;
9765
9766   result = (Dali::Radian *)&Dali::ANGLE_90;
9767   jresult = (void *)result;
9768   return jresult;
9769 }
9770
9771
9772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9773   void * jresult ;
9774   Dali::Radian *result = 0 ;
9775
9776   result = (Dali::Radian *)&Dali::ANGLE_60;
9777   jresult = (void *)result;
9778   return jresult;
9779 }
9780
9781
9782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9783   void * jresult ;
9784   Dali::Radian *result = 0 ;
9785
9786   result = (Dali::Radian *)&Dali::ANGLE_45;
9787   jresult = (void *)result;
9788   return jresult;
9789 }
9790
9791
9792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9793   void * jresult ;
9794   Dali::Radian *result = 0 ;
9795
9796   result = (Dali::Radian *)&Dali::ANGLE_30;
9797   jresult = (void *)result;
9798   return jresult;
9799 }
9800
9801
9802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9803   void * jresult ;
9804   Dali::Radian *result = 0 ;
9805
9806   result = (Dali::Radian *)&Dali::ANGLE_0;
9807   jresult = (void *)result;
9808   return jresult;
9809 }
9810
9811
9812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9813   unsigned int jresult ;
9814   Dali::Degree *arg1 = 0 ;
9815   Dali::Degree *arg2 = 0 ;
9816   bool result;
9817
9818   arg1 = (Dali::Degree *)jarg1;
9819   if (!arg1) {
9820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9821     return 0;
9822   }
9823   arg2 = (Dali::Degree *)jarg2;
9824   if (!arg2) {
9825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9826     return 0;
9827   }
9828   {
9829     try {
9830       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9831     } catch (std::out_of_range& e) {
9832       {
9833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9834       };
9835     } catch (std::exception& e) {
9836       {
9837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9838       };
9839     } catch (Dali::DaliException e) {
9840       {
9841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9842       };
9843     } catch (...) {
9844       {
9845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9846       };
9847     }
9848   }
9849
9850   jresult = result;
9851   return jresult;
9852 }
9853
9854
9855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9856   unsigned int jresult ;
9857   Dali::Degree *arg1 = 0 ;
9858   Dali::Degree *arg2 = 0 ;
9859   bool result;
9860
9861   arg1 = (Dali::Degree *)jarg1;
9862   if (!arg1) {
9863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9864     return 0;
9865   }
9866   arg2 = (Dali::Degree *)jarg2;
9867   if (!arg2) {
9868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9869     return 0;
9870   }
9871   {
9872     try {
9873       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9874     } catch (std::out_of_range& e) {
9875       {
9876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9877       };
9878     } catch (std::exception& e) {
9879       {
9880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9881       };
9882     } catch (Dali::DaliException e) {
9883       {
9884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9885       };
9886     } catch (...) {
9887       {
9888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9889       };
9890     }
9891   }
9892
9893   jresult = result;
9894   return jresult;
9895 }
9896
9897
9898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9899   void * jresult ;
9900   Dali::Degree arg1 ;
9901   float arg2 ;
9902   float arg3 ;
9903   Dali::Degree *argp1 ;
9904   Dali::Degree result;
9905
9906   argp1 = (Dali::Degree *)jarg1;
9907   if (!argp1) {
9908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9909     return 0;
9910   }
9911   arg1 = *argp1;
9912   arg2 = (float)jarg2;
9913   arg3 = (float)jarg3;
9914   {
9915     try {
9916       result = Dali::Clamp(arg1,arg2,arg3);
9917     } catch (std::out_of_range& e) {
9918       {
9919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9920       };
9921     } catch (std::exception& e) {
9922       {
9923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9924       };
9925     } catch (Dali::DaliException e) {
9926       {
9927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9928       };
9929     } catch (...) {
9930       {
9931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9932       };
9933     }
9934   }
9935
9936   jresult = new Dali::Degree((const Dali::Degree &)result);
9937   return jresult;
9938 }
9939
9940
9941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9942   void * jresult ;
9943   Dali::Radian *result = 0 ;
9944
9945   {
9946     try {
9947       result = (Dali::Radian *)new Dali::Radian();
9948     } catch (std::out_of_range& e) {
9949       {
9950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9951       };
9952     } catch (std::exception& e) {
9953       {
9954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9955       };
9956     } catch (Dali::DaliException e) {
9957       {
9958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9959       };
9960     } catch (...) {
9961       {
9962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9963       };
9964     }
9965   }
9966
9967   jresult = (void *)result;
9968   return jresult;
9969 }
9970
9971
9972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9973   void * jresult ;
9974   float arg1 ;
9975   Dali::Radian *result = 0 ;
9976
9977   arg1 = (float)jarg1;
9978   {
9979     try {
9980       result = (Dali::Radian *)new Dali::Radian(arg1);
9981     } catch (std::out_of_range& e) {
9982       {
9983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9984       };
9985     } catch (std::exception& e) {
9986       {
9987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9988       };
9989     } catch (Dali::DaliException e) {
9990       {
9991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9992       };
9993     } catch (...) {
9994       {
9995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9996       };
9997     }
9998   }
9999
10000   jresult = (void *)result;
10001   return jresult;
10002 }
10003
10004
10005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10006   void * jresult ;
10007   Dali::Degree arg1 ;
10008   Dali::Degree *argp1 ;
10009   Dali::Radian *result = 0 ;
10010
10011   argp1 = (Dali::Degree *)jarg1;
10012   if (!argp1) {
10013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10014     return 0;
10015   }
10016   arg1 = *argp1;
10017   {
10018     try {
10019       result = (Dali::Radian *)new Dali::Radian(arg1);
10020     } catch (std::out_of_range& e) {
10021       {
10022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10023       };
10024     } catch (std::exception& e) {
10025       {
10026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10027       };
10028     } catch (Dali::DaliException e) {
10029       {
10030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10031       };
10032     } catch (...) {
10033       {
10034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10035       };
10036     }
10037   }
10038
10039   jresult = (void *)result;
10040   return jresult;
10041 }
10042
10043
10044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10045   void * jresult ;
10046   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10047   float arg2 ;
10048   Dali::Radian *result = 0 ;
10049
10050   arg1 = (Dali::Radian *)jarg1;
10051   arg2 = (float)jarg2;
10052   {
10053     try {
10054       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10055     } catch (std::out_of_range& e) {
10056       {
10057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10058       };
10059     } catch (std::exception& e) {
10060       {
10061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10062       };
10063     } catch (Dali::DaliException e) {
10064       {
10065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10066       };
10067     } catch (...) {
10068       {
10069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10070       };
10071     }
10072   }
10073
10074   jresult = (void *)result;
10075   return jresult;
10076 }
10077
10078
10079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10080   void * jresult ;
10081   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10082   Dali::Degree arg2 ;
10083   Dali::Degree *argp2 ;
10084   Dali::Radian *result = 0 ;
10085
10086   arg1 = (Dali::Radian *)jarg1;
10087   argp2 = (Dali::Degree *)jarg2;
10088   if (!argp2) {
10089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10090     return 0;
10091   }
10092   arg2 = *argp2;
10093   {
10094     try {
10095       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10096     } catch (std::out_of_range& e) {
10097       {
10098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10099       };
10100     } catch (std::exception& e) {
10101       {
10102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10103       };
10104     } catch (Dali::DaliException e) {
10105       {
10106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10107       };
10108     } catch (...) {
10109       {
10110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10111       };
10112     }
10113   }
10114
10115   jresult = (void *)result;
10116   return jresult;
10117 }
10118
10119
10120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10121   float jresult ;
10122   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10123   float result;
10124
10125   arg1 = (Dali::Radian *)jarg1;
10126   {
10127     try {
10128       result = (float)((Dali::Radian const *)arg1)->operator float();
10129     } catch (std::out_of_range& e) {
10130       {
10131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10132       };
10133     } catch (std::exception& e) {
10134       {
10135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10136       };
10137     } catch (Dali::DaliException e) {
10138       {
10139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10140       };
10141     } catch (...) {
10142       {
10143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10144       };
10145     }
10146   }
10147
10148   jresult = result;
10149   return jresult;
10150 }
10151
10152
10153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10154   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10155   float arg2 ;
10156
10157   arg1 = (Dali::Radian *)jarg1;
10158   arg2 = (float)jarg2;
10159   if (arg1) (arg1)->radian = arg2;
10160 }
10161
10162
10163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10164   float jresult ;
10165   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10166   float result;
10167
10168   arg1 = (Dali::Radian *)jarg1;
10169   result = (float) ((arg1)->radian);
10170   jresult = result;
10171   return jresult;
10172 }
10173
10174
10175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10176   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10177
10178   arg1 = (Dali::Radian *)jarg1;
10179   {
10180     try {
10181       delete arg1;
10182     } catch (std::out_of_range& e) {
10183       {
10184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10185       };
10186     } catch (std::exception& e) {
10187       {
10188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10189       };
10190     } catch (Dali::DaliException e) {
10191       {
10192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10193       };
10194     } catch (...) {
10195       {
10196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10197       };
10198     }
10199   }
10200
10201 }
10202
10203
10204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10205   unsigned int jresult ;
10206   Dali::Radian arg1 ;
10207   Dali::Radian arg2 ;
10208   Dali::Radian *argp1 ;
10209   Dali::Radian *argp2 ;
10210   bool result;
10211
10212   argp1 = (Dali::Radian *)jarg1;
10213   if (!argp1) {
10214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10215     return 0;
10216   }
10217   arg1 = *argp1;
10218   argp2 = (Dali::Radian *)jarg2;
10219   if (!argp2) {
10220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10221     return 0;
10222   }
10223   arg2 = *argp2;
10224   {
10225     try {
10226       result = (bool)Dali::operator ==(arg1,arg2);
10227     } catch (std::out_of_range& e) {
10228       {
10229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10230       };
10231     } catch (std::exception& e) {
10232       {
10233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10234       };
10235     } catch (Dali::DaliException e) {
10236       {
10237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10238       };
10239     } catch (...) {
10240       {
10241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10242       };
10243     }
10244   }
10245
10246   jresult = result;
10247   return jresult;
10248 }
10249
10250
10251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10252   unsigned int jresult ;
10253   Dali::Radian arg1 ;
10254   Dali::Radian arg2 ;
10255   Dali::Radian *argp1 ;
10256   Dali::Radian *argp2 ;
10257   bool result;
10258
10259   argp1 = (Dali::Radian *)jarg1;
10260   if (!argp1) {
10261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10262     return 0;
10263   }
10264   arg1 = *argp1;
10265   argp2 = (Dali::Radian *)jarg2;
10266   if (!argp2) {
10267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10268     return 0;
10269   }
10270   arg2 = *argp2;
10271   {
10272     try {
10273       result = (bool)Dali::operator !=(arg1,arg2);
10274     } catch (std::out_of_range& e) {
10275       {
10276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10277       };
10278     } catch (std::exception& e) {
10279       {
10280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10281       };
10282     } catch (Dali::DaliException e) {
10283       {
10284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10285       };
10286     } catch (...) {
10287       {
10288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10289       };
10290     }
10291   }
10292
10293   jresult = result;
10294   return jresult;
10295 }
10296
10297
10298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10299   unsigned int jresult ;
10300   Dali::Radian arg1 ;
10301   Dali::Degree arg2 ;
10302   Dali::Radian *argp1 ;
10303   Dali::Degree *argp2 ;
10304   bool result;
10305
10306   argp1 = (Dali::Radian *)jarg1;
10307   if (!argp1) {
10308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10309     return 0;
10310   }
10311   arg1 = *argp1;
10312   argp2 = (Dali::Degree *)jarg2;
10313   if (!argp2) {
10314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10315     return 0;
10316   }
10317   arg2 = *argp2;
10318   {
10319     try {
10320       result = (bool)Dali::operator ==(arg1,arg2);
10321     } catch (std::out_of_range& e) {
10322       {
10323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10324       };
10325     } catch (std::exception& e) {
10326       {
10327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10328       };
10329     } catch (Dali::DaliException e) {
10330       {
10331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10332       };
10333     } catch (...) {
10334       {
10335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10336       };
10337     }
10338   }
10339
10340   jresult = result;
10341   return jresult;
10342 }
10343
10344
10345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10346   unsigned int jresult ;
10347   Dali::Radian arg1 ;
10348   Dali::Degree arg2 ;
10349   Dali::Radian *argp1 ;
10350   Dali::Degree *argp2 ;
10351   bool result;
10352
10353   argp1 = (Dali::Radian *)jarg1;
10354   if (!argp1) {
10355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10356     return 0;
10357   }
10358   arg1 = *argp1;
10359   argp2 = (Dali::Degree *)jarg2;
10360   if (!argp2) {
10361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10362     return 0;
10363   }
10364   arg2 = *argp2;
10365   {
10366     try {
10367       result = (bool)Dali::operator !=(arg1,arg2);
10368     } catch (std::out_of_range& e) {
10369       {
10370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10371       };
10372     } catch (std::exception& e) {
10373       {
10374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10375       };
10376     } catch (Dali::DaliException e) {
10377       {
10378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10379       };
10380     } catch (...) {
10381       {
10382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10383       };
10384     }
10385   }
10386
10387   jresult = result;
10388   return jresult;
10389 }
10390
10391
10392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10393   unsigned int jresult ;
10394   Dali::Degree arg1 ;
10395   Dali::Radian arg2 ;
10396   Dali::Degree *argp1 ;
10397   Dali::Radian *argp2 ;
10398   bool result;
10399
10400   argp1 = (Dali::Degree *)jarg1;
10401   if (!argp1) {
10402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10403     return 0;
10404   }
10405   arg1 = *argp1;
10406   argp2 = (Dali::Radian *)jarg2;
10407   if (!argp2) {
10408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10409     return 0;
10410   }
10411   arg2 = *argp2;
10412   {
10413     try {
10414       result = (bool)Dali::operator ==(arg1,arg2);
10415     } catch (std::out_of_range& e) {
10416       {
10417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10418       };
10419     } catch (std::exception& e) {
10420       {
10421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10422       };
10423     } catch (Dali::DaliException e) {
10424       {
10425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10426       };
10427     } catch (...) {
10428       {
10429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10430       };
10431     }
10432   }
10433
10434   jresult = result;
10435   return jresult;
10436 }
10437
10438
10439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10440   unsigned int jresult ;
10441   Dali::Degree arg1 ;
10442   Dali::Radian arg2 ;
10443   Dali::Degree *argp1 ;
10444   Dali::Radian *argp2 ;
10445   bool result;
10446
10447   argp1 = (Dali::Degree *)jarg1;
10448   if (!argp1) {
10449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10450     return 0;
10451   }
10452   arg1 = *argp1;
10453   argp2 = (Dali::Radian *)jarg2;
10454   if (!argp2) {
10455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10456     return 0;
10457   }
10458   arg2 = *argp2;
10459   {
10460     try {
10461       result = (bool)Dali::operator !=(arg1,arg2);
10462     } catch (std::out_of_range& e) {
10463       {
10464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10465       };
10466     } catch (std::exception& e) {
10467       {
10468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10469       };
10470     } catch (Dali::DaliException e) {
10471       {
10472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10473       };
10474     } catch (...) {
10475       {
10476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10477       };
10478     }
10479   }
10480
10481   jresult = result;
10482   return jresult;
10483 }
10484
10485
10486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10487   unsigned int jresult ;
10488   Dali::Radian arg1 ;
10489   Dali::Radian arg2 ;
10490   Dali::Radian *argp1 ;
10491   Dali::Radian *argp2 ;
10492   bool result;
10493
10494   argp1 = (Dali::Radian *)jarg1;
10495   if (!argp1) {
10496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10497     return 0;
10498   }
10499   arg1 = *argp1;
10500   argp2 = (Dali::Radian *)jarg2;
10501   if (!argp2) {
10502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10503     return 0;
10504   }
10505   arg2 = *argp2;
10506   {
10507     try {
10508       result = (bool)Dali::operator >(arg1,arg2);
10509     } catch (std::out_of_range& e) {
10510       {
10511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10512       };
10513     } catch (std::exception& e) {
10514       {
10515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10516       };
10517     } catch (Dali::DaliException e) {
10518       {
10519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10520       };
10521     } catch (...) {
10522       {
10523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10524       };
10525     }
10526   }
10527
10528   jresult = result;
10529   return jresult;
10530 }
10531
10532
10533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10534   unsigned int jresult ;
10535   Dali::Radian arg1 ;
10536   Dali::Degree arg2 ;
10537   Dali::Radian *argp1 ;
10538   Dali::Degree *argp2 ;
10539   bool result;
10540
10541   argp1 = (Dali::Radian *)jarg1;
10542   if (!argp1) {
10543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10544     return 0;
10545   }
10546   arg1 = *argp1;
10547   argp2 = (Dali::Degree *)jarg2;
10548   if (!argp2) {
10549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10550     return 0;
10551   }
10552   arg2 = *argp2;
10553   {
10554     try {
10555       result = (bool)Dali::operator >(arg1,arg2);
10556     } catch (std::out_of_range& e) {
10557       {
10558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10559       };
10560     } catch (std::exception& e) {
10561       {
10562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10563       };
10564     } catch (Dali::DaliException e) {
10565       {
10566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10567       };
10568     } catch (...) {
10569       {
10570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10571       };
10572     }
10573   }
10574
10575   jresult = result;
10576   return jresult;
10577 }
10578
10579
10580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10581   unsigned int jresult ;
10582   Dali::Degree arg1 ;
10583   Dali::Radian arg2 ;
10584   Dali::Degree *argp1 ;
10585   Dali::Radian *argp2 ;
10586   bool result;
10587
10588   argp1 = (Dali::Degree *)jarg1;
10589   if (!argp1) {
10590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10591     return 0;
10592   }
10593   arg1 = *argp1;
10594   argp2 = (Dali::Radian *)jarg2;
10595   if (!argp2) {
10596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10597     return 0;
10598   }
10599   arg2 = *argp2;
10600   {
10601     try {
10602       result = (bool)Dali::operator >(arg1,arg2);
10603     } catch (std::out_of_range& e) {
10604       {
10605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10606       };
10607     } catch (std::exception& e) {
10608       {
10609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10610       };
10611     } catch (Dali::DaliException e) {
10612       {
10613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10614       };
10615     } catch (...) {
10616       {
10617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10618       };
10619     }
10620   }
10621
10622   jresult = result;
10623   return jresult;
10624 }
10625
10626
10627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10628   unsigned int jresult ;
10629   Dali::Radian arg1 ;
10630   Dali::Radian arg2 ;
10631   Dali::Radian *argp1 ;
10632   Dali::Radian *argp2 ;
10633   bool result;
10634
10635   argp1 = (Dali::Radian *)jarg1;
10636   if (!argp1) {
10637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10638     return 0;
10639   }
10640   arg1 = *argp1;
10641   argp2 = (Dali::Radian *)jarg2;
10642   if (!argp2) {
10643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10644     return 0;
10645   }
10646   arg2 = *argp2;
10647   {
10648     try {
10649       result = (bool)Dali::operator <(arg1,arg2);
10650     } catch (std::out_of_range& e) {
10651       {
10652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10653       };
10654     } catch (std::exception& e) {
10655       {
10656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10657       };
10658     } catch (Dali::DaliException e) {
10659       {
10660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10661       };
10662     } catch (...) {
10663       {
10664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10665       };
10666     }
10667   }
10668
10669   jresult = result;
10670   return jresult;
10671 }
10672
10673
10674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10675   unsigned int jresult ;
10676   Dali::Radian arg1 ;
10677   Dali::Degree arg2 ;
10678   Dali::Radian *argp1 ;
10679   Dali::Degree *argp2 ;
10680   bool result;
10681
10682   argp1 = (Dali::Radian *)jarg1;
10683   if (!argp1) {
10684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10685     return 0;
10686   }
10687   arg1 = *argp1;
10688   argp2 = (Dali::Degree *)jarg2;
10689   if (!argp2) {
10690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10691     return 0;
10692   }
10693   arg2 = *argp2;
10694   {
10695     try {
10696       result = (bool)Dali::operator <(arg1,arg2);
10697     } catch (std::out_of_range& e) {
10698       {
10699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10700       };
10701     } catch (std::exception& e) {
10702       {
10703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10704       };
10705     } catch (Dali::DaliException e) {
10706       {
10707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10708       };
10709     } catch (...) {
10710       {
10711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10712       };
10713     }
10714   }
10715
10716   jresult = result;
10717   return jresult;
10718 }
10719
10720
10721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10722   unsigned int jresult ;
10723   Dali::Degree arg1 ;
10724   Dali::Radian arg2 ;
10725   Dali::Degree *argp1 ;
10726   Dali::Radian *argp2 ;
10727   bool result;
10728
10729   argp1 = (Dali::Degree *)jarg1;
10730   if (!argp1) {
10731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10732     return 0;
10733   }
10734   arg1 = *argp1;
10735   argp2 = (Dali::Radian *)jarg2;
10736   if (!argp2) {
10737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10738     return 0;
10739   }
10740   arg2 = *argp2;
10741   {
10742     try {
10743       result = (bool)Dali::operator <(arg1,arg2);
10744     } catch (std::out_of_range& e) {
10745       {
10746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10747       };
10748     } catch (std::exception& e) {
10749       {
10750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10751       };
10752     } catch (Dali::DaliException e) {
10753       {
10754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10755       };
10756     } catch (...) {
10757       {
10758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10759       };
10760     }
10761   }
10762
10763   jresult = result;
10764   return jresult;
10765 }
10766
10767
10768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10769   void * jresult ;
10770   Dali::Radian arg1 ;
10771   float arg2 ;
10772   Dali::Radian *argp1 ;
10773   Dali::Radian result;
10774
10775   argp1 = (Dali::Radian *)jarg1;
10776   if (!argp1) {
10777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10778     return 0;
10779   }
10780   arg1 = *argp1;
10781   arg2 = (float)jarg2;
10782   {
10783     try {
10784       result = Dali::operator *(arg1,arg2);
10785     } catch (std::out_of_range& e) {
10786       {
10787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10788       };
10789     } catch (std::exception& e) {
10790       {
10791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10792       };
10793     } catch (Dali::DaliException e) {
10794       {
10795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10796       };
10797     } catch (...) {
10798       {
10799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10800       };
10801     }
10802   }
10803
10804   jresult = new Dali::Radian((const Dali::Radian &)result);
10805   return jresult;
10806 }
10807
10808
10809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10810   void * jresult ;
10811   Dali::Radian arg1 ;
10812   Dali::Radian *argp1 ;
10813   Dali::Radian result;
10814
10815   argp1 = (Dali::Radian *)jarg1;
10816   if (!argp1) {
10817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10818     return 0;
10819   }
10820   arg1 = *argp1;
10821   {
10822     try {
10823       result = Dali::operator -(arg1);
10824     } catch (std::out_of_range& e) {
10825       {
10826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10827       };
10828     } catch (std::exception& e) {
10829       {
10830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10831       };
10832     } catch (Dali::DaliException e) {
10833       {
10834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10835       };
10836     } catch (...) {
10837       {
10838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10839       };
10840     }
10841   }
10842
10843   jresult = new Dali::Radian((const Dali::Radian &)result);
10844   return jresult;
10845 }
10846
10847
10848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10849   void * jresult ;
10850   Dali::Radian arg1 ;
10851   float arg2 ;
10852   float arg3 ;
10853   Dali::Radian *argp1 ;
10854   Dali::Radian result;
10855
10856   argp1 = (Dali::Radian *)jarg1;
10857   if (!argp1) {
10858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10859     return 0;
10860   }
10861   arg1 = *argp1;
10862   arg2 = (float)jarg2;
10863   arg3 = (float)jarg3;
10864   {
10865     try {
10866       result = Dali::Clamp(arg1,arg2,arg3);
10867     } catch (std::out_of_range& e) {
10868       {
10869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10870       };
10871     } catch (std::exception& e) {
10872       {
10873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10874       };
10875     } catch (Dali::DaliException e) {
10876       {
10877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10878       };
10879     } catch (...) {
10880       {
10881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10882       };
10883     }
10884   }
10885
10886   jresult = new Dali::Radian((const Dali::Radian &)result);
10887   return jresult;
10888 }
10889
10890
10891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10892   void * jresult ;
10893   Dali::Quaternion *result = 0 ;
10894
10895   {
10896     try {
10897       result = (Dali::Quaternion *)new Dali::Quaternion();
10898     } catch (std::out_of_range& e) {
10899       {
10900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10901       };
10902     } catch (std::exception& e) {
10903       {
10904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10905       };
10906     } catch (Dali::DaliException e) {
10907       {
10908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10909       };
10910     } catch (...) {
10911       {
10912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10913       };
10914     }
10915   }
10916
10917   jresult = (void *)result;
10918   return jresult;
10919 }
10920
10921
10922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10923   void * jresult ;
10924   Dali::Radian arg1 ;
10925   Dali::Vector3 *arg2 = 0 ;
10926   Dali::Radian *argp1 ;
10927   Dali::Quaternion *result = 0 ;
10928
10929   argp1 = (Dali::Radian *)jarg1;
10930   if (!argp1) {
10931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10932     return 0;
10933   }
10934   arg1 = *argp1;
10935   arg2 = (Dali::Vector3 *)jarg2;
10936   if (!arg2) {
10937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10938     return 0;
10939   }
10940   {
10941     try {
10942       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10943     } catch (std::out_of_range& e) {
10944       {
10945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10946       };
10947     } catch (std::exception& e) {
10948       {
10949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10950       };
10951     } catch (Dali::DaliException e) {
10952       {
10953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10954       };
10955     } catch (...) {
10956       {
10957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10958       };
10959     }
10960   }
10961
10962   jresult = (void *)result;
10963   return jresult;
10964 }
10965
10966
10967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10968   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10969
10970   arg1 = (Dali::Quaternion *)jarg1;
10971   {
10972     try {
10973       delete arg1;
10974     } catch (std::out_of_range& e) {
10975       {
10976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10977       };
10978     } catch (std::exception& e) {
10979       {
10980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10981       };
10982     } catch (Dali::DaliException e) {
10983       {
10984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10985       };
10986     } catch (...) {
10987       {
10988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10989       };
10990     }
10991   }
10992
10993 }
10994
10995
10996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10997   void * jresult ;
10998   Dali::Quaternion *result = 0 ;
10999
11000   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11001   jresult = (void *)result;
11002   return jresult;
11003 }
11004
11005
11006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11007   unsigned int jresult ;
11008   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11009   bool result;
11010
11011   arg1 = (Dali::Quaternion *)jarg1;
11012   {
11013     try {
11014       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11015     } catch (std::out_of_range& e) {
11016       {
11017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11018       };
11019     } catch (std::exception& e) {
11020       {
11021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11022       };
11023     } catch (Dali::DaliException e) {
11024       {
11025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11026       };
11027     } catch (...) {
11028       {
11029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11030       };
11031     }
11032   }
11033
11034   jresult = result;
11035   return jresult;
11036 }
11037
11038
11039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11040   unsigned int jresult ;
11041   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11042   Dali::Vector3 *arg2 = 0 ;
11043   Dali::Radian *arg3 = 0 ;
11044   bool result;
11045
11046   arg1 = (Dali::Quaternion *)jarg1;
11047   arg2 = (Dali::Vector3 *)jarg2;
11048   if (!arg2) {
11049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11050     return 0;
11051   }
11052   arg3 = (Dali::Radian *)jarg3;
11053   if (!arg3) {
11054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11055     return 0;
11056   }
11057   {
11058     try {
11059       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11060     } catch (std::out_of_range& e) {
11061       {
11062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11063       };
11064     } catch (std::exception& e) {
11065       {
11066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11067       };
11068     } catch (Dali::DaliException e) {
11069       {
11070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11071       };
11072     } catch (...) {
11073       {
11074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11075       };
11076     }
11077   }
11078
11079   jresult = result;
11080   return jresult;
11081 }
11082
11083
11084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11085   void * jresult ;
11086   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11087   Dali::Quaternion *arg2 = 0 ;
11088   Dali::Quaternion result;
11089
11090   arg1 = (Dali::Quaternion *)jarg1;
11091   arg2 = (Dali::Quaternion *)jarg2;
11092   if (!arg2) {
11093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11094     return 0;
11095   }
11096   {
11097     try {
11098       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11099     } catch (std::out_of_range& e) {
11100       {
11101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11102       };
11103     } catch (std::exception& e) {
11104       {
11105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11106       };
11107     } catch (Dali::DaliException e) {
11108       {
11109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11110       };
11111     } catch (...) {
11112       {
11113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11114       };
11115     }
11116   }
11117
11118   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11119   return jresult;
11120 }
11121
11122
11123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11124   void * jresult ;
11125   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11126   Dali::Quaternion *arg2 = 0 ;
11127   Dali::Quaternion result;
11128
11129   arg1 = (Dali::Quaternion *)jarg1;
11130   arg2 = (Dali::Quaternion *)jarg2;
11131   if (!arg2) {
11132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11133     return 0;
11134   }
11135   {
11136     try {
11137       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11138     } catch (std::out_of_range& e) {
11139       {
11140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11141       };
11142     } catch (std::exception& e) {
11143       {
11144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11145       };
11146     } catch (Dali::DaliException e) {
11147       {
11148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11149       };
11150     } catch (...) {
11151       {
11152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11153       };
11154     }
11155   }
11156
11157   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11158   return jresult;
11159 }
11160
11161
11162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11163   void * jresult ;
11164   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11165   Dali::Quaternion *arg2 = 0 ;
11166   Dali::Quaternion result;
11167
11168   arg1 = (Dali::Quaternion *)jarg1;
11169   arg2 = (Dali::Quaternion *)jarg2;
11170   if (!arg2) {
11171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11172     return 0;
11173   }
11174   {
11175     try {
11176       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11177     } catch (std::out_of_range& e) {
11178       {
11179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11180       };
11181     } catch (std::exception& e) {
11182       {
11183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11184       };
11185     } catch (Dali::DaliException e) {
11186       {
11187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11188       };
11189     } catch (...) {
11190       {
11191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11192       };
11193     }
11194   }
11195
11196   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11197   return jresult;
11198 }
11199
11200
11201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11202   void * jresult ;
11203   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11204   Dali::Vector3 *arg2 = 0 ;
11205   Dali::Vector3 result;
11206
11207   arg1 = (Dali::Quaternion *)jarg1;
11208   arg2 = (Dali::Vector3 *)jarg2;
11209   if (!arg2) {
11210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11211     return 0;
11212   }
11213   {
11214     try {
11215       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11216     } catch (std::out_of_range& e) {
11217       {
11218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11219       };
11220     } catch (std::exception& e) {
11221       {
11222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11223       };
11224     } catch (Dali::DaliException e) {
11225       {
11226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11227       };
11228     } catch (...) {
11229       {
11230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11231       };
11232     }
11233   }
11234
11235   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11236   return jresult;
11237 }
11238
11239
11240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11241   void * jresult ;
11242   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11243   Dali::Quaternion *arg2 = 0 ;
11244   Dali::Quaternion result;
11245
11246   arg1 = (Dali::Quaternion *)jarg1;
11247   arg2 = (Dali::Quaternion *)jarg2;
11248   if (!arg2) {
11249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11250     return 0;
11251   }
11252   {
11253     try {
11254       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11255     } catch (std::out_of_range& e) {
11256       {
11257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11258       };
11259     } catch (std::exception& e) {
11260       {
11261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11262       };
11263     } catch (Dali::DaliException e) {
11264       {
11265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11266       };
11267     } catch (...) {
11268       {
11269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11270       };
11271     }
11272   }
11273
11274   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11275   return jresult;
11276 }
11277
11278
11279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11280   void * jresult ;
11281   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11282   float arg2 ;
11283   Dali::Quaternion result;
11284
11285   arg1 = (Dali::Quaternion *)jarg1;
11286   arg2 = (float)jarg2;
11287   {
11288     try {
11289       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11290     } catch (std::out_of_range& e) {
11291       {
11292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11293       };
11294     } catch (std::exception& e) {
11295       {
11296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11297       };
11298     } catch (Dali::DaliException e) {
11299       {
11300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11301       };
11302     } catch (...) {
11303       {
11304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11305       };
11306     }
11307   }
11308
11309   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11310   return jresult;
11311 }
11312
11313
11314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11315   void * jresult ;
11316   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11317   float arg2 ;
11318   Dali::Quaternion result;
11319
11320   arg1 = (Dali::Quaternion *)jarg1;
11321   arg2 = (float)jarg2;
11322   {
11323     try {
11324       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11325     } catch (std::out_of_range& e) {
11326       {
11327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11328       };
11329     } catch (std::exception& e) {
11330       {
11331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11332       };
11333     } catch (Dali::DaliException e) {
11334       {
11335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11336       };
11337     } catch (...) {
11338       {
11339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11340       };
11341     }
11342   }
11343
11344   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11345   return jresult;
11346 }
11347
11348
11349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11350   void * jresult ;
11351   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11352   Dali::Quaternion result;
11353
11354   arg1 = (Dali::Quaternion *)jarg1;
11355   {
11356     try {
11357       result = ((Dali::Quaternion const *)arg1)->operator -();
11358     } catch (std::out_of_range& e) {
11359       {
11360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11361       };
11362     } catch (std::exception& e) {
11363       {
11364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11365       };
11366     } catch (Dali::DaliException e) {
11367       {
11368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11369       };
11370     } catch (...) {
11371       {
11372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11373       };
11374     }
11375   }
11376
11377   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11378   return jresult;
11379 }
11380
11381
11382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11383   void * jresult ;
11384   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11385   Dali::Quaternion *arg2 = 0 ;
11386   Dali::Quaternion *result = 0 ;
11387
11388   arg1 = (Dali::Quaternion *)jarg1;
11389   arg2 = (Dali::Quaternion *)jarg2;
11390   if (!arg2) {
11391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11392     return 0;
11393   }
11394   {
11395     try {
11396       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11397     } catch (std::out_of_range& e) {
11398       {
11399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11400       };
11401     } catch (std::exception& e) {
11402       {
11403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11404       };
11405     } catch (Dali::DaliException e) {
11406       {
11407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11408       };
11409     } catch (...) {
11410       {
11411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11412       };
11413     }
11414   }
11415
11416   jresult = (void *)result;
11417   return jresult;
11418 }
11419
11420
11421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11422   void * jresult ;
11423   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11424   Dali::Quaternion *arg2 = 0 ;
11425   Dali::Quaternion *result = 0 ;
11426
11427   arg1 = (Dali::Quaternion *)jarg1;
11428   arg2 = (Dali::Quaternion *)jarg2;
11429   if (!arg2) {
11430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11431     return 0;
11432   }
11433   {
11434     try {
11435       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11436     } catch (std::out_of_range& e) {
11437       {
11438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11439       };
11440     } catch (std::exception& e) {
11441       {
11442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11443       };
11444     } catch (Dali::DaliException e) {
11445       {
11446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11447       };
11448     } catch (...) {
11449       {
11450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11451       };
11452     }
11453   }
11454
11455   jresult = (void *)result;
11456   return jresult;
11457 }
11458
11459
11460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11461   void * jresult ;
11462   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11463   Dali::Quaternion *arg2 = 0 ;
11464   Dali::Quaternion *result = 0 ;
11465
11466   arg1 = (Dali::Quaternion *)jarg1;
11467   arg2 = (Dali::Quaternion *)jarg2;
11468   if (!arg2) {
11469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11470     return 0;
11471   }
11472   {
11473     try {
11474       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11475     } catch (std::out_of_range& e) {
11476       {
11477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11478       };
11479     } catch (std::exception& e) {
11480       {
11481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11482       };
11483     } catch (Dali::DaliException e) {
11484       {
11485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11486       };
11487     } catch (...) {
11488       {
11489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11490       };
11491     }
11492   }
11493
11494   jresult = (void *)result;
11495   return jresult;
11496 }
11497
11498
11499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11500   void * jresult ;
11501   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11502   float arg2 ;
11503   Dali::Quaternion *result = 0 ;
11504
11505   arg1 = (Dali::Quaternion *)jarg1;
11506   arg2 = (float)jarg2;
11507   {
11508     try {
11509       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11510     } catch (std::out_of_range& e) {
11511       {
11512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11513       };
11514     } catch (std::exception& e) {
11515       {
11516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11517       };
11518     } catch (Dali::DaliException e) {
11519       {
11520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11521       };
11522     } catch (...) {
11523       {
11524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11525       };
11526     }
11527   }
11528
11529   jresult = (void *)result;
11530   return jresult;
11531 }
11532
11533
11534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11535   void * jresult ;
11536   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11537   float arg2 ;
11538   Dali::Quaternion *result = 0 ;
11539
11540   arg1 = (Dali::Quaternion *)jarg1;
11541   arg2 = (float)jarg2;
11542   {
11543     try {
11544       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11545     } catch (std::out_of_range& e) {
11546       {
11547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11548       };
11549     } catch (std::exception& e) {
11550       {
11551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11552       };
11553     } catch (Dali::DaliException e) {
11554       {
11555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11556       };
11557     } catch (...) {
11558       {
11559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11560       };
11561     }
11562   }
11563
11564   jresult = (void *)result;
11565   return jresult;
11566 }
11567
11568
11569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11570   unsigned int jresult ;
11571   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11572   Dali::Quaternion *arg2 = 0 ;
11573   bool result;
11574
11575   arg1 = (Dali::Quaternion *)jarg1;
11576   arg2 = (Dali::Quaternion *)jarg2;
11577   if (!arg2) {
11578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11579     return 0;
11580   }
11581   {
11582     try {
11583       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11584     } catch (std::out_of_range& e) {
11585       {
11586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11587       };
11588     } catch (std::exception& e) {
11589       {
11590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11591       };
11592     } catch (Dali::DaliException e) {
11593       {
11594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11595       };
11596     } catch (...) {
11597       {
11598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11599       };
11600     }
11601   }
11602
11603   jresult = result;
11604   return jresult;
11605 }
11606
11607
11608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11609   unsigned int jresult ;
11610   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11611   Dali::Quaternion *arg2 = 0 ;
11612   bool result;
11613
11614   arg1 = (Dali::Quaternion *)jarg1;
11615   arg2 = (Dali::Quaternion *)jarg2;
11616   if (!arg2) {
11617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11618     return 0;
11619   }
11620   {
11621     try {
11622       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11623     } catch (std::out_of_range& e) {
11624       {
11625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11626       };
11627     } catch (std::exception& e) {
11628       {
11629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11630       };
11631     } catch (Dali::DaliException e) {
11632       {
11633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11634       };
11635     } catch (...) {
11636       {
11637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11638       };
11639     }
11640   }
11641
11642   jresult = result;
11643   return jresult;
11644 }
11645
11646
11647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11648   float jresult ;
11649   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11650   float result;
11651
11652   arg1 = (Dali::Quaternion *)jarg1;
11653   {
11654     try {
11655       result = (float)((Dali::Quaternion const *)arg1)->Length();
11656     } catch (std::out_of_range& e) {
11657       {
11658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11659       };
11660     } catch (std::exception& e) {
11661       {
11662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11663       };
11664     } catch (Dali::DaliException e) {
11665       {
11666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11667       };
11668     } catch (...) {
11669       {
11670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11671       };
11672     }
11673   }
11674
11675   jresult = result;
11676   return jresult;
11677 }
11678
11679
11680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11681   float jresult ;
11682   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11683   float result;
11684
11685   arg1 = (Dali::Quaternion *)jarg1;
11686   {
11687     try {
11688       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11689     } catch (std::out_of_range& e) {
11690       {
11691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11692       };
11693     } catch (std::exception& e) {
11694       {
11695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11696       };
11697     } catch (Dali::DaliException e) {
11698       {
11699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11700       };
11701     } catch (...) {
11702       {
11703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11704       };
11705     }
11706   }
11707
11708   jresult = result;
11709   return jresult;
11710 }
11711
11712
11713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11714   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11715
11716   arg1 = (Dali::Quaternion *)jarg1;
11717   {
11718     try {
11719       (arg1)->Normalize();
11720     } catch (std::out_of_range& e) {
11721       {
11722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11723       };
11724     } catch (std::exception& e) {
11725       {
11726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11727       };
11728     } catch (Dali::DaliException e) {
11729       {
11730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11731       };
11732     } catch (...) {
11733       {
11734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11735       };
11736     }
11737   }
11738
11739 }
11740
11741
11742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11743   void * jresult ;
11744   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11745   Dali::Quaternion result;
11746
11747   arg1 = (Dali::Quaternion *)jarg1;
11748   {
11749     try {
11750       result = ((Dali::Quaternion const *)arg1)->Normalized();
11751     } catch (std::out_of_range& e) {
11752       {
11753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11754       };
11755     } catch (std::exception& e) {
11756       {
11757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11758       };
11759     } catch (Dali::DaliException e) {
11760       {
11761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11762       };
11763     } catch (...) {
11764       {
11765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11766       };
11767     }
11768   }
11769
11770   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11771   return jresult;
11772 }
11773
11774
11775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11776   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11777
11778   arg1 = (Dali::Quaternion *)jarg1;
11779   {
11780     try {
11781       (arg1)->Conjugate();
11782     } catch (std::out_of_range& e) {
11783       {
11784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11785       };
11786     } catch (std::exception& e) {
11787       {
11788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11789       };
11790     } catch (Dali::DaliException e) {
11791       {
11792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11793       };
11794     } catch (...) {
11795       {
11796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11797       };
11798     }
11799   }
11800
11801 }
11802
11803
11804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11805   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11806
11807   arg1 = (Dali::Quaternion *)jarg1;
11808   {
11809     try {
11810       (arg1)->Invert();
11811     } catch (std::out_of_range& e) {
11812       {
11813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11814       };
11815     } catch (std::exception& e) {
11816       {
11817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11818       };
11819     } catch (Dali::DaliException e) {
11820       {
11821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11822       };
11823     } catch (...) {
11824       {
11825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11826       };
11827     }
11828   }
11829
11830 }
11831
11832
11833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11834   void * jresult ;
11835   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11836   Dali::Quaternion result;
11837
11838   arg1 = (Dali::Quaternion *)jarg1;
11839   {
11840     try {
11841       result = ((Dali::Quaternion const *)arg1)->Log();
11842     } catch (std::out_of_range& e) {
11843       {
11844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11845       };
11846     } catch (std::exception& e) {
11847       {
11848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11849       };
11850     } catch (Dali::DaliException e) {
11851       {
11852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11853       };
11854     } catch (...) {
11855       {
11856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11857       };
11858     }
11859   }
11860
11861   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11862   return jresult;
11863 }
11864
11865
11866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11867   void * jresult ;
11868   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11869   Dali::Quaternion result;
11870
11871   arg1 = (Dali::Quaternion *)jarg1;
11872   {
11873     try {
11874       result = ((Dali::Quaternion const *)arg1)->Exp();
11875     } catch (std::out_of_range& e) {
11876       {
11877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11878       };
11879     } catch (std::exception& e) {
11880       {
11881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11882       };
11883     } catch (Dali::DaliException e) {
11884       {
11885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11886       };
11887     } catch (...) {
11888       {
11889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11890       };
11891     }
11892   }
11893
11894   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11895   return jresult;
11896 }
11897
11898
11899 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11900   float jresult ;
11901   Dali::Quaternion *arg1 = 0 ;
11902   Dali::Quaternion *arg2 = 0 ;
11903   float result;
11904
11905   arg1 = (Dali::Quaternion *)jarg1;
11906   if (!arg1) {
11907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11908     return 0;
11909   }
11910   arg2 = (Dali::Quaternion *)jarg2;
11911   if (!arg2) {
11912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11913     return 0;
11914   }
11915   {
11916     try {
11917       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11918     } catch (std::out_of_range& e) {
11919       {
11920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11921       };
11922     } catch (std::exception& e) {
11923       {
11924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11925       };
11926     } catch (Dali::DaliException e) {
11927       {
11928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11929       };
11930     } catch (...) {
11931       {
11932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11933       };
11934     }
11935   }
11936
11937   jresult = result;
11938   return jresult;
11939 }
11940
11941
11942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11943   void * jresult ;
11944   Dali::Quaternion *arg1 = 0 ;
11945   Dali::Quaternion *arg2 = 0 ;
11946   float arg3 ;
11947   Dali::Quaternion result;
11948
11949   arg1 = (Dali::Quaternion *)jarg1;
11950   if (!arg1) {
11951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11952     return 0;
11953   }
11954   arg2 = (Dali::Quaternion *)jarg2;
11955   if (!arg2) {
11956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11957     return 0;
11958   }
11959   arg3 = (float)jarg3;
11960   {
11961     try {
11962       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11963     } catch (std::out_of_range& e) {
11964       {
11965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11966       };
11967     } catch (std::exception& e) {
11968       {
11969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11970       };
11971     } catch (Dali::DaliException e) {
11972       {
11973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11974       };
11975     } catch (...) {
11976       {
11977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11978       };
11979     }
11980   }
11981
11982   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11983   return jresult;
11984 }
11985
11986
11987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11988   void * jresult ;
11989   Dali::Quaternion *arg1 = 0 ;
11990   Dali::Quaternion *arg2 = 0 ;
11991   float arg3 ;
11992   Dali::Quaternion result;
11993
11994   arg1 = (Dali::Quaternion *)jarg1;
11995   if (!arg1) {
11996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11997     return 0;
11998   }
11999   arg2 = (Dali::Quaternion *)jarg2;
12000   if (!arg2) {
12001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12002     return 0;
12003   }
12004   arg3 = (float)jarg3;
12005   {
12006     try {
12007       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12008     } catch (std::out_of_range& e) {
12009       {
12010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12011       };
12012     } catch (std::exception& e) {
12013       {
12014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12015       };
12016     } catch (Dali::DaliException e) {
12017       {
12018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12019       };
12020     } catch (...) {
12021       {
12022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12023       };
12024     }
12025   }
12026
12027   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12028   return jresult;
12029 }
12030
12031
12032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12033   void * jresult ;
12034   Dali::Quaternion *arg1 = 0 ;
12035   Dali::Quaternion *arg2 = 0 ;
12036   float arg3 ;
12037   Dali::Quaternion result;
12038
12039   arg1 = (Dali::Quaternion *)jarg1;
12040   if (!arg1) {
12041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12042     return 0;
12043   }
12044   arg2 = (Dali::Quaternion *)jarg2;
12045   if (!arg2) {
12046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12047     return 0;
12048   }
12049   arg3 = (float)jarg3;
12050   {
12051     try {
12052       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12053     } catch (std::out_of_range& e) {
12054       {
12055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12056       };
12057     } catch (std::exception& e) {
12058       {
12059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12060       };
12061     } catch (Dali::DaliException e) {
12062       {
12063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12064       };
12065     } catch (...) {
12066       {
12067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12068       };
12069     }
12070   }
12071
12072   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12073   return jresult;
12074 }
12075
12076
12077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12078   void * jresult ;
12079   Dali::Quaternion *arg1 = 0 ;
12080   Dali::Quaternion *arg2 = 0 ;
12081   Dali::Quaternion *arg3 = 0 ;
12082   Dali::Quaternion *arg4 = 0 ;
12083   float arg5 ;
12084   Dali::Quaternion result;
12085
12086   arg1 = (Dali::Quaternion *)jarg1;
12087   if (!arg1) {
12088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12089     return 0;
12090   }
12091   arg2 = (Dali::Quaternion *)jarg2;
12092   if (!arg2) {
12093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12094     return 0;
12095   }
12096   arg3 = (Dali::Quaternion *)jarg3;
12097   if (!arg3) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12099     return 0;
12100   }
12101   arg4 = (Dali::Quaternion *)jarg4;
12102   if (!arg4) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12104     return 0;
12105   }
12106   arg5 = (float)jarg5;
12107   {
12108     try {
12109       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12110     } catch (std::out_of_range& e) {
12111       {
12112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12113       };
12114     } catch (std::exception& e) {
12115       {
12116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12117       };
12118     } catch (Dali::DaliException e) {
12119       {
12120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12121       };
12122     } catch (...) {
12123       {
12124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12125       };
12126     }
12127   }
12128
12129   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12130   return jresult;
12131 }
12132
12133
12134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12135   float jresult ;
12136   Dali::Quaternion *arg1 = 0 ;
12137   Dali::Quaternion *arg2 = 0 ;
12138   float result;
12139
12140   arg1 = (Dali::Quaternion *)jarg1;
12141   if (!arg1) {
12142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12143     return 0;
12144   }
12145   arg2 = (Dali::Quaternion *)jarg2;
12146   if (!arg2) {
12147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12148     return 0;
12149   }
12150   {
12151     try {
12152       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12153     } catch (std::out_of_range& e) {
12154       {
12155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12156       };
12157     } catch (std::exception& e) {
12158       {
12159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12160       };
12161     } catch (Dali::DaliException e) {
12162       {
12163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12164       };
12165     } catch (...) {
12166       {
12167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12168       };
12169     }
12170   }
12171
12172   jresult = result;
12173   return jresult;
12174 }
12175
12176
12177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12178   void * jresult ;
12179   Dali::Matrix *result = 0 ;
12180
12181   {
12182     try {
12183       result = (Dali::Matrix *)new Dali::Matrix();
12184     } catch (std::out_of_range& e) {
12185       {
12186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12187       };
12188     } catch (std::exception& e) {
12189       {
12190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12191       };
12192     } catch (Dali::DaliException e) {
12193       {
12194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12195       };
12196     } catch (...) {
12197       {
12198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12199       };
12200     }
12201   }
12202
12203   jresult = (void *)result;
12204   return jresult;
12205 }
12206
12207
12208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12209   void * jresult ;
12210   bool arg1 ;
12211   Dali::Matrix *result = 0 ;
12212
12213   arg1 = jarg1 ? true : false;
12214   {
12215     try {
12216       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12217     } catch (std::out_of_range& e) {
12218       {
12219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12220       };
12221     } catch (std::exception& e) {
12222       {
12223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12224       };
12225     } catch (Dali::DaliException e) {
12226       {
12227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12228       };
12229     } catch (...) {
12230       {
12231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12232       };
12233     }
12234   }
12235
12236   jresult = (void *)result;
12237   return jresult;
12238 }
12239
12240
12241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12242   void * jresult ;
12243   float *arg1 = (float *) 0 ;
12244   Dali::Matrix *result = 0 ;
12245
12246   arg1 = jarg1;
12247   {
12248     try {
12249       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12250     } catch (std::out_of_range& e) {
12251       {
12252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12253       };
12254     } catch (std::exception& e) {
12255       {
12256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12257       };
12258     } catch (Dali::DaliException e) {
12259       {
12260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12261       };
12262     } catch (...) {
12263       {
12264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12265       };
12266     }
12267   }
12268
12269   jresult = (void *)result;
12270
12271
12272   return jresult;
12273 }
12274
12275
12276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12277   void * jresult ;
12278   Dali::Quaternion *arg1 = 0 ;
12279   Dali::Matrix *result = 0 ;
12280
12281   arg1 = (Dali::Quaternion *)jarg1;
12282   if (!arg1) {
12283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12284     return 0;
12285   }
12286   {
12287     try {
12288       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12289     } catch (std::out_of_range& e) {
12290       {
12291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12292       };
12293     } catch (std::exception& e) {
12294       {
12295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12296       };
12297     } catch (Dali::DaliException e) {
12298       {
12299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12300       };
12301     } catch (...) {
12302       {
12303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12304       };
12305     }
12306   }
12307
12308   jresult = (void *)result;
12309   return jresult;
12310 }
12311
12312
12313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12314   void * jresult ;
12315   Dali::Matrix *arg1 = 0 ;
12316   Dali::Matrix *result = 0 ;
12317
12318   arg1 = (Dali::Matrix *)jarg1;
12319   if (!arg1) {
12320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12321     return 0;
12322   }
12323   {
12324     try {
12325       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12326     } catch (std::out_of_range& e) {
12327       {
12328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12329       };
12330     } catch (std::exception& e) {
12331       {
12332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12333       };
12334     } catch (Dali::DaliException e) {
12335       {
12336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12337       };
12338     } catch (...) {
12339       {
12340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12341       };
12342     }
12343   }
12344
12345   jresult = (void *)result;
12346   return jresult;
12347 }
12348
12349
12350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12351   void * jresult ;
12352   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12353   Dali::Matrix *arg2 = 0 ;
12354   Dali::Matrix *result = 0 ;
12355
12356   arg1 = (Dali::Matrix *)jarg1;
12357   arg2 = (Dali::Matrix *)jarg2;
12358   if (!arg2) {
12359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12360     return 0;
12361   }
12362   {
12363     try {
12364       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12365     } catch (std::out_of_range& e) {
12366       {
12367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12368       };
12369     } catch (std::exception& e) {
12370       {
12371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12372       };
12373     } catch (Dali::DaliException e) {
12374       {
12375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12376       };
12377     } catch (...) {
12378       {
12379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12380       };
12381     }
12382   }
12383
12384   jresult = (void *)result;
12385   return jresult;
12386 }
12387
12388
12389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12390   void * jresult ;
12391   Dali::Matrix *result = 0 ;
12392
12393   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12394   jresult = (void *)result;
12395   return jresult;
12396 }
12397
12398
12399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12400   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12401
12402   arg1 = (Dali::Matrix *)jarg1;
12403   {
12404     try {
12405       (arg1)->SetIdentity();
12406     } catch (std::out_of_range& e) {
12407       {
12408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12409       };
12410     } catch (std::exception& e) {
12411       {
12412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12413       };
12414     } catch (Dali::DaliException e) {
12415       {
12416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12417       };
12418     } catch (...) {
12419       {
12420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12421       };
12422     }
12423   }
12424
12425 }
12426
12427
12428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12429   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12430   Dali::Vector3 *arg2 = 0 ;
12431
12432   arg1 = (Dali::Matrix *)jarg1;
12433   arg2 = (Dali::Vector3 *)jarg2;
12434   if (!arg2) {
12435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12436     return ;
12437   }
12438   {
12439     try {
12440       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12441     } catch (std::out_of_range& e) {
12442       {
12443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12444       };
12445     } catch (std::exception& e) {
12446       {
12447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12448       };
12449     } catch (Dali::DaliException e) {
12450       {
12451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12452       };
12453     } catch (...) {
12454       {
12455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12456       };
12457     }
12458   }
12459
12460 }
12461
12462
12463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12464   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12465   Dali::Matrix *arg2 = 0 ;
12466
12467   arg1 = (Dali::Matrix *)jarg1;
12468   arg2 = (Dali::Matrix *)jarg2;
12469   if (!arg2) {
12470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12471     return ;
12472   }
12473   {
12474     try {
12475       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12476     } catch (std::out_of_range& e) {
12477       {
12478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12479       };
12480     } catch (std::exception& e) {
12481       {
12482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12483       };
12484     } catch (Dali::DaliException e) {
12485       {
12486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12487       };
12488     } catch (...) {
12489       {
12490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12491       };
12492     }
12493   }
12494
12495 }
12496
12497
12498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12499   unsigned int jresult ;
12500   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12501   bool result;
12502
12503   arg1 = (Dali::Matrix *)jarg1;
12504   {
12505     try {
12506       result = (bool)(arg1)->Invert();
12507     } catch (std::out_of_range& e) {
12508       {
12509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12510       };
12511     } catch (std::exception& e) {
12512       {
12513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12514       };
12515     } catch (Dali::DaliException e) {
12516       {
12517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12518       };
12519     } catch (...) {
12520       {
12521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12522       };
12523     }
12524   }
12525
12526   jresult = result;
12527   return jresult;
12528 }
12529
12530
12531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12532   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12533
12534   arg1 = (Dali::Matrix *)jarg1;
12535   {
12536     try {
12537       (arg1)->Transpose();
12538     } catch (std::out_of_range& e) {
12539       {
12540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12541       };
12542     } catch (std::exception& e) {
12543       {
12544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12545       };
12546     } catch (Dali::DaliException e) {
12547       {
12548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12549       };
12550     } catch (...) {
12551       {
12552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12553       };
12554     }
12555   }
12556
12557 }
12558
12559
12560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12561   void * jresult ;
12562   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12563   Dali::Vector3 result;
12564
12565   arg1 = (Dali::Matrix *)jarg1;
12566   {
12567     try {
12568       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12569     } catch (std::out_of_range& e) {
12570       {
12571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12572       };
12573     } catch (std::exception& e) {
12574       {
12575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12576       };
12577     } catch (Dali::DaliException e) {
12578       {
12579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12580       };
12581     } catch (...) {
12582       {
12583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12584       };
12585     }
12586   }
12587
12588   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12589   return jresult;
12590 }
12591
12592
12593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12594   void * jresult ;
12595   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12596   Dali::Vector3 result;
12597
12598   arg1 = (Dali::Matrix *)jarg1;
12599   {
12600     try {
12601       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12602     } catch (std::out_of_range& e) {
12603       {
12604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12605       };
12606     } catch (std::exception& e) {
12607       {
12608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12609       };
12610     } catch (Dali::DaliException e) {
12611       {
12612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12613       };
12614     } catch (...) {
12615       {
12616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12617       };
12618     }
12619   }
12620
12621   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12622   return jresult;
12623 }
12624
12625
12626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12627   void * jresult ;
12628   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12629   Dali::Vector3 result;
12630
12631   arg1 = (Dali::Matrix *)jarg1;
12632   {
12633     try {
12634       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12635     } catch (std::out_of_range& e) {
12636       {
12637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12638       };
12639     } catch (std::exception& e) {
12640       {
12641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12642       };
12643     } catch (Dali::DaliException e) {
12644       {
12645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12646       };
12647     } catch (...) {
12648       {
12649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12650       };
12651     }
12652   }
12653
12654   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12655   return jresult;
12656 }
12657
12658
12659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12660   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12661   Dali::Vector3 *arg2 = 0 ;
12662
12663   arg1 = (Dali::Matrix *)jarg1;
12664   arg2 = (Dali::Vector3 *)jarg2;
12665   if (!arg2) {
12666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12667     return ;
12668   }
12669   {
12670     try {
12671       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12672     } catch (std::out_of_range& e) {
12673       {
12674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12675       };
12676     } catch (std::exception& e) {
12677       {
12678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12679       };
12680     } catch (Dali::DaliException e) {
12681       {
12682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12683       };
12684     } catch (...) {
12685       {
12686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12687       };
12688     }
12689   }
12690
12691 }
12692
12693
12694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12695   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12696   Dali::Vector3 *arg2 = 0 ;
12697
12698   arg1 = (Dali::Matrix *)jarg1;
12699   arg2 = (Dali::Vector3 *)jarg2;
12700   if (!arg2) {
12701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12702     return ;
12703   }
12704   {
12705     try {
12706       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12707     } catch (std::out_of_range& e) {
12708       {
12709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12710       };
12711     } catch (std::exception& e) {
12712       {
12713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12714       };
12715     } catch (Dali::DaliException e) {
12716       {
12717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12718       };
12719     } catch (...) {
12720       {
12721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12722       };
12723     }
12724   }
12725
12726 }
12727
12728
12729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12730   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12731   Dali::Vector3 *arg2 = 0 ;
12732
12733   arg1 = (Dali::Matrix *)jarg1;
12734   arg2 = (Dali::Vector3 *)jarg2;
12735   if (!arg2) {
12736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12737     return ;
12738   }
12739   {
12740     try {
12741       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12742     } catch (std::out_of_range& e) {
12743       {
12744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12745       };
12746     } catch (std::exception& e) {
12747       {
12748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12749       };
12750     } catch (Dali::DaliException e) {
12751       {
12752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12753       };
12754     } catch (...) {
12755       {
12756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12757       };
12758     }
12759   }
12760
12761 }
12762
12763
12764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12765   void * jresult ;
12766   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12767   Dali::Vector4 *result = 0 ;
12768
12769   arg1 = (Dali::Matrix *)jarg1;
12770   {
12771     try {
12772       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12773     } catch (std::out_of_range& e) {
12774       {
12775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12776       };
12777     } catch (std::exception& e) {
12778       {
12779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12780       };
12781     } catch (Dali::DaliException e) {
12782       {
12783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12784       };
12785     } catch (...) {
12786       {
12787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12788       };
12789     }
12790   }
12791
12792   jresult = (void *)result;
12793   return jresult;
12794 }
12795
12796
12797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12798   void * jresult ;
12799   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12800   Dali::Vector3 *result = 0 ;
12801
12802   arg1 = (Dali::Matrix *)jarg1;
12803   {
12804     try {
12805       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12806     } catch (std::out_of_range& e) {
12807       {
12808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12809       };
12810     } catch (std::exception& e) {
12811       {
12812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12813       };
12814     } catch (Dali::DaliException e) {
12815       {
12816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12817       };
12818     } catch (...) {
12819       {
12820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12821       };
12822     }
12823   }
12824
12825   jresult = (void *)result;
12826   return jresult;
12827 }
12828
12829
12830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12831   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12832   Dali::Vector4 *arg2 = 0 ;
12833
12834   arg1 = (Dali::Matrix *)jarg1;
12835   arg2 = (Dali::Vector4 *)jarg2;
12836   if (!arg2) {
12837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12838     return ;
12839   }
12840   {
12841     try {
12842       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12843     } catch (std::out_of_range& e) {
12844       {
12845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12846       };
12847     } catch (std::exception& e) {
12848       {
12849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12850       };
12851     } catch (Dali::DaliException e) {
12852       {
12853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12854       };
12855     } catch (...) {
12856       {
12857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12858       };
12859     }
12860   }
12861
12862 }
12863
12864
12865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12866   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12867   Dali::Vector3 *arg2 = 0 ;
12868
12869   arg1 = (Dali::Matrix *)jarg1;
12870   arg2 = (Dali::Vector3 *)jarg2;
12871   if (!arg2) {
12872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12873     return ;
12874   }
12875   {
12876     try {
12877       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12878     } catch (std::out_of_range& e) {
12879       {
12880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12881       };
12882     } catch (std::exception& e) {
12883       {
12884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12885       };
12886     } catch (Dali::DaliException e) {
12887       {
12888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12889       };
12890     } catch (...) {
12891       {
12892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12893       };
12894     }
12895   }
12896
12897 }
12898
12899
12900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12901   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12902
12903   arg1 = (Dali::Matrix *)jarg1;
12904   {
12905     try {
12906       (arg1)->OrthoNormalize();
12907     } catch (std::out_of_range& e) {
12908       {
12909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12910       };
12911     } catch (std::exception& e) {
12912       {
12913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12914       };
12915     } catch (Dali::DaliException e) {
12916       {
12917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12918       };
12919     } catch (...) {
12920       {
12921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12922       };
12923     }
12924   }
12925
12926 }
12927
12928
12929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12930   void * jresult ;
12931   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12932   float *result = 0 ;
12933
12934   arg1 = (Dali::Matrix *)jarg1;
12935   {
12936     try {
12937       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12938     } catch (std::out_of_range& e) {
12939       {
12940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12941       };
12942     } catch (std::exception& e) {
12943       {
12944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12945       };
12946     } catch (Dali::DaliException e) {
12947       {
12948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12949       };
12950     } catch (...) {
12951       {
12952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12953       };
12954     }
12955   }
12956
12957   jresult = (void *)result;
12958   return jresult;
12959 }
12960
12961
12962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12963   Dali::Matrix *arg1 = 0 ;
12964   Dali::Matrix *arg2 = 0 ;
12965   Dali::Matrix *arg3 = 0 ;
12966
12967   arg1 = (Dali::Matrix *)jarg1;
12968   if (!arg1) {
12969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12970     return ;
12971   }
12972   arg2 = (Dali::Matrix *)jarg2;
12973   if (!arg2) {
12974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12975     return ;
12976   }
12977   arg3 = (Dali::Matrix *)jarg3;
12978   if (!arg3) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12980     return ;
12981   }
12982   {
12983     try {
12984       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12985     } catch (std::out_of_range& e) {
12986       {
12987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12988       };
12989     } catch (std::exception& e) {
12990       {
12991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12992       };
12993     } catch (Dali::DaliException e) {
12994       {
12995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12996       };
12997     } catch (...) {
12998       {
12999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13000       };
13001     }
13002   }
13003
13004 }
13005
13006
13007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13008   Dali::Matrix *arg1 = 0 ;
13009   Dali::Matrix *arg2 = 0 ;
13010   Dali::Quaternion *arg3 = 0 ;
13011
13012   arg1 = (Dali::Matrix *)jarg1;
13013   if (!arg1) {
13014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13015     return ;
13016   }
13017   arg2 = (Dali::Matrix *)jarg2;
13018   if (!arg2) {
13019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13020     return ;
13021   }
13022   arg3 = (Dali::Quaternion *)jarg3;
13023   if (!arg3) {
13024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13025     return ;
13026   }
13027   {
13028     try {
13029       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13030     } catch (std::out_of_range& e) {
13031       {
13032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13033       };
13034     } catch (std::exception& e) {
13035       {
13036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13037       };
13038     } catch (Dali::DaliException e) {
13039       {
13040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13041       };
13042     } catch (...) {
13043       {
13044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13045       };
13046     }
13047   }
13048
13049 }
13050
13051
13052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13053   void * jresult ;
13054   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13055   Dali::Vector4 *arg2 = 0 ;
13056   Dali::Vector4 result;
13057
13058   arg1 = (Dali::Matrix *)jarg1;
13059   arg2 = (Dali::Vector4 *)jarg2;
13060   if (!arg2) {
13061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13062     return 0;
13063   }
13064   {
13065     try {
13066       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13067     } catch (std::out_of_range& e) {
13068       {
13069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13070       };
13071     } catch (std::exception& e) {
13072       {
13073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13074       };
13075     } catch (Dali::DaliException e) {
13076       {
13077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13078       };
13079     } catch (...) {
13080       {
13081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13082       };
13083     }
13084   }
13085
13086   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13087   return jresult;
13088 }
13089
13090
13091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13092   unsigned int jresult ;
13093   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13094   Dali::Matrix *arg2 = 0 ;
13095   bool result;
13096
13097   arg1 = (Dali::Matrix *)jarg1;
13098   arg2 = (Dali::Matrix *)jarg2;
13099   if (!arg2) {
13100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13101     return 0;
13102   }
13103   {
13104     try {
13105       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13106     } catch (std::out_of_range& e) {
13107       {
13108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13109       };
13110     } catch (std::exception& e) {
13111       {
13112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13113       };
13114     } catch (Dali::DaliException e) {
13115       {
13116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13117       };
13118     } catch (...) {
13119       {
13120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13121       };
13122     }
13123   }
13124
13125   jresult = result;
13126   return jresult;
13127 }
13128
13129
13130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13131   unsigned int jresult ;
13132   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13133   Dali::Matrix *arg2 = 0 ;
13134   bool result;
13135
13136   arg1 = (Dali::Matrix *)jarg1;
13137   arg2 = (Dali::Matrix *)jarg2;
13138   if (!arg2) {
13139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13140     return 0;
13141   }
13142   {
13143     try {
13144       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13145     } catch (std::out_of_range& e) {
13146       {
13147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13148       };
13149     } catch (std::exception& e) {
13150       {
13151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13152       };
13153     } catch (Dali::DaliException e) {
13154       {
13155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13156       };
13157     } catch (...) {
13158       {
13159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13160       };
13161     }
13162   }
13163
13164   jresult = result;
13165   return jresult;
13166 }
13167
13168
13169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13170   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13171   Dali::Vector3 *arg2 = 0 ;
13172   Dali::Quaternion *arg3 = 0 ;
13173   Dali::Vector3 *arg4 = 0 ;
13174
13175   arg1 = (Dali::Matrix *)jarg1;
13176   arg2 = (Dali::Vector3 *)jarg2;
13177   if (!arg2) {
13178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13179     return ;
13180   }
13181   arg3 = (Dali::Quaternion *)jarg3;
13182   if (!arg3) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13184     return ;
13185   }
13186   arg4 = (Dali::Vector3 *)jarg4;
13187   if (!arg4) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13189     return ;
13190   }
13191   {
13192     try {
13193       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13194     } catch (std::out_of_range& e) {
13195       {
13196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13197       };
13198     } catch (std::exception& e) {
13199       {
13200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13201       };
13202     } catch (Dali::DaliException e) {
13203       {
13204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13205       };
13206     } catch (...) {
13207       {
13208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13209       };
13210     }
13211   }
13212
13213 }
13214
13215
13216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13217   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13218   Dali::Vector3 *arg2 = 0 ;
13219   Dali::Quaternion *arg3 = 0 ;
13220   Dali::Vector3 *arg4 = 0 ;
13221
13222   arg1 = (Dali::Matrix *)jarg1;
13223   arg2 = (Dali::Vector3 *)jarg2;
13224   if (!arg2) {
13225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13226     return ;
13227   }
13228   arg3 = (Dali::Quaternion *)jarg3;
13229   if (!arg3) {
13230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13231     return ;
13232   }
13233   arg4 = (Dali::Vector3 *)jarg4;
13234   if (!arg4) {
13235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13236     return ;
13237   }
13238   {
13239     try {
13240       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13241     } catch (std::out_of_range& e) {
13242       {
13243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13244       };
13245     } catch (std::exception& e) {
13246       {
13247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13248       };
13249     } catch (Dali::DaliException e) {
13250       {
13251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13252       };
13253     } catch (...) {
13254       {
13255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13256       };
13257     }
13258   }
13259
13260 }
13261
13262
13263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13264   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13265   Dali::Vector3 *arg2 = 0 ;
13266   Dali::Vector3 *arg3 = 0 ;
13267   Dali::Vector3 *arg4 = 0 ;
13268   Dali::Vector3 *arg5 = 0 ;
13269
13270   arg1 = (Dali::Matrix *)jarg1;
13271   arg2 = (Dali::Vector3 *)jarg2;
13272   if (!arg2) {
13273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13274     return ;
13275   }
13276   arg3 = (Dali::Vector3 *)jarg3;
13277   if (!arg3) {
13278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13279     return ;
13280   }
13281   arg4 = (Dali::Vector3 *)jarg4;
13282   if (!arg4) {
13283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13284     return ;
13285   }
13286   arg5 = (Dali::Vector3 *)jarg5;
13287   if (!arg5) {
13288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13289     return ;
13290   }
13291   {
13292     try {
13293       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13294     } catch (std::out_of_range& e) {
13295       {
13296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13297       };
13298     } catch (std::exception& e) {
13299       {
13300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13301       };
13302     } catch (Dali::DaliException e) {
13303       {
13304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13305       };
13306     } catch (...) {
13307       {
13308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13309       };
13310     }
13311   }
13312
13313 }
13314
13315
13316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13317   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13318   Dali::Vector3 *arg2 = 0 ;
13319   Dali::Quaternion *arg3 = 0 ;
13320   Dali::Vector3 *arg4 = 0 ;
13321
13322   arg1 = (Dali::Matrix *)jarg1;
13323   arg2 = (Dali::Vector3 *)jarg2;
13324   if (!arg2) {
13325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13326     return ;
13327   }
13328   arg3 = (Dali::Quaternion *)jarg3;
13329   if (!arg3) {
13330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13331     return ;
13332   }
13333   arg4 = (Dali::Vector3 *)jarg4;
13334   if (!arg4) {
13335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13336     return ;
13337   }
13338   {
13339     try {
13340       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13341     } catch (std::out_of_range& e) {
13342       {
13343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13344       };
13345     } catch (std::exception& e) {
13346       {
13347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13348       };
13349     } catch (Dali::DaliException e) {
13350       {
13351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13352       };
13353     } catch (...) {
13354       {
13355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13356       };
13357     }
13358   }
13359
13360 }
13361
13362
13363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13364   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13365
13366   arg1 = (Dali::Matrix *)jarg1;
13367   {
13368     try {
13369       delete arg1;
13370     } catch (std::out_of_range& e) {
13371       {
13372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13373       };
13374     } catch (std::exception& e) {
13375       {
13376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13377       };
13378     } catch (Dali::DaliException e) {
13379       {
13380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13381       };
13382     } catch (...) {
13383       {
13384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13385       };
13386     }
13387   }
13388
13389 }
13390
13391
13392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13393   void * jresult ;
13394   Dali::Matrix3 *result = 0 ;
13395
13396   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13397   jresult = (void *)result;
13398   return jresult;
13399 }
13400
13401
13402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13403   void * jresult ;
13404   Dali::Matrix3 *result = 0 ;
13405
13406   {
13407     try {
13408       result = (Dali::Matrix3 *)new Dali::Matrix3();
13409     } catch (std::out_of_range& e) {
13410       {
13411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13412       };
13413     } catch (std::exception& e) {
13414       {
13415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13416       };
13417     } catch (Dali::DaliException e) {
13418       {
13419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13420       };
13421     } catch (...) {
13422       {
13423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13424       };
13425     }
13426   }
13427
13428   jresult = (void *)result;
13429   return jresult;
13430 }
13431
13432
13433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13434   void * jresult ;
13435   Dali::Matrix3 *arg1 = 0 ;
13436   Dali::Matrix3 *result = 0 ;
13437
13438   arg1 = (Dali::Matrix3 *)jarg1;
13439   if (!arg1) {
13440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13441     return 0;
13442   }
13443   {
13444     try {
13445       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13446     } catch (std::out_of_range& e) {
13447       {
13448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13449       };
13450     } catch (std::exception& e) {
13451       {
13452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13453       };
13454     } catch (Dali::DaliException e) {
13455       {
13456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13457       };
13458     } catch (...) {
13459       {
13460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13461       };
13462     }
13463   }
13464
13465   jresult = (void *)result;
13466   return jresult;
13467 }
13468
13469
13470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13471   void * jresult ;
13472   Dali::Matrix *arg1 = 0 ;
13473   Dali::Matrix3 *result = 0 ;
13474
13475   arg1 = (Dali::Matrix *)jarg1;
13476   if (!arg1) {
13477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13478     return 0;
13479   }
13480   {
13481     try {
13482       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13483     } catch (std::out_of_range& e) {
13484       {
13485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13486       };
13487     } catch (std::exception& e) {
13488       {
13489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13490       };
13491     } catch (Dali::DaliException e) {
13492       {
13493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13494       };
13495     } catch (...) {
13496       {
13497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13498       };
13499     }
13500   }
13501
13502   jresult = (void *)result;
13503   return jresult;
13504 }
13505
13506
13507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13508   void * jresult ;
13509   float arg1 ;
13510   float arg2 ;
13511   float arg3 ;
13512   float arg4 ;
13513   float arg5 ;
13514   float arg6 ;
13515   float arg7 ;
13516   float arg8 ;
13517   float arg9 ;
13518   Dali::Matrix3 *result = 0 ;
13519
13520   arg1 = (float)jarg1;
13521   arg2 = (float)jarg2;
13522   arg3 = (float)jarg3;
13523   arg4 = (float)jarg4;
13524   arg5 = (float)jarg5;
13525   arg6 = (float)jarg6;
13526   arg7 = (float)jarg7;
13527   arg8 = (float)jarg8;
13528   arg9 = (float)jarg9;
13529   {
13530     try {
13531       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13532     } catch (std::out_of_range& e) {
13533       {
13534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13535       };
13536     } catch (std::exception& e) {
13537       {
13538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13539       };
13540     } catch (Dali::DaliException e) {
13541       {
13542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13543       };
13544     } catch (...) {
13545       {
13546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13547       };
13548     }
13549   }
13550
13551   jresult = (void *)result;
13552   return jresult;
13553 }
13554
13555
13556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13557   void * jresult ;
13558   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13559   Dali::Matrix3 *arg2 = 0 ;
13560   Dali::Matrix3 *result = 0 ;
13561
13562   arg1 = (Dali::Matrix3 *)jarg1;
13563   arg2 = (Dali::Matrix3 *)jarg2;
13564   if (!arg2) {
13565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13566     return 0;
13567   }
13568   {
13569     try {
13570       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13571     } catch (std::out_of_range& e) {
13572       {
13573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13574       };
13575     } catch (std::exception& e) {
13576       {
13577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13578       };
13579     } catch (Dali::DaliException e) {
13580       {
13581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13582       };
13583     } catch (...) {
13584       {
13585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13586       };
13587     }
13588   }
13589
13590   jresult = (void *)result;
13591   return jresult;
13592 }
13593
13594
13595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13596   void * jresult ;
13597   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13598   Dali::Matrix *arg2 = 0 ;
13599   Dali::Matrix3 *result = 0 ;
13600
13601   arg1 = (Dali::Matrix3 *)jarg1;
13602   arg2 = (Dali::Matrix *)jarg2;
13603   if (!arg2) {
13604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13605     return 0;
13606   }
13607   {
13608     try {
13609       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13610     } catch (std::out_of_range& e) {
13611       {
13612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13613       };
13614     } catch (std::exception& e) {
13615       {
13616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13617       };
13618     } catch (Dali::DaliException e) {
13619       {
13620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13621       };
13622     } catch (...) {
13623       {
13624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13625       };
13626     }
13627   }
13628
13629   jresult = (void *)result;
13630   return jresult;
13631 }
13632
13633
13634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13635   unsigned int jresult ;
13636   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13637   Dali::Matrix3 *arg2 = 0 ;
13638   bool result;
13639
13640   arg1 = (Dali::Matrix3 *)jarg1;
13641   arg2 = (Dali::Matrix3 *)jarg2;
13642   if (!arg2) {
13643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13644     return 0;
13645   }
13646   {
13647     try {
13648       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13649     } catch (std::out_of_range& e) {
13650       {
13651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13652       };
13653     } catch (std::exception& e) {
13654       {
13655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13656       };
13657     } catch (Dali::DaliException e) {
13658       {
13659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13660       };
13661     } catch (...) {
13662       {
13663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13664       };
13665     }
13666   }
13667
13668   jresult = result;
13669   return jresult;
13670 }
13671
13672
13673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13674   unsigned int jresult ;
13675   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13676   Dali::Matrix3 *arg2 = 0 ;
13677   bool result;
13678
13679   arg1 = (Dali::Matrix3 *)jarg1;
13680   arg2 = (Dali::Matrix3 *)jarg2;
13681   if (!arg2) {
13682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13683     return 0;
13684   }
13685   {
13686     try {
13687       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13688     } catch (std::out_of_range& e) {
13689       {
13690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13691       };
13692     } catch (std::exception& e) {
13693       {
13694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13695       };
13696     } catch (Dali::DaliException e) {
13697       {
13698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13699       };
13700     } catch (...) {
13701       {
13702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13703       };
13704     }
13705   }
13706
13707   jresult = result;
13708   return jresult;
13709 }
13710
13711
13712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13713   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13714
13715   arg1 = (Dali::Matrix3 *)jarg1;
13716   {
13717     try {
13718       delete arg1;
13719     } catch (std::out_of_range& e) {
13720       {
13721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13722       };
13723     } catch (std::exception& e) {
13724       {
13725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13726       };
13727     } catch (Dali::DaliException e) {
13728       {
13729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13730       };
13731     } catch (...) {
13732       {
13733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13734       };
13735     }
13736   }
13737
13738 }
13739
13740
13741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13742   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13743
13744   arg1 = (Dali::Matrix3 *)jarg1;
13745   {
13746     try {
13747       (arg1)->SetIdentity();
13748     } catch (std::out_of_range& e) {
13749       {
13750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13751       };
13752     } catch (std::exception& e) {
13753       {
13754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13755       };
13756     } catch (Dali::DaliException e) {
13757       {
13758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13759       };
13760     } catch (...) {
13761       {
13762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13763       };
13764     }
13765   }
13766
13767 }
13768
13769
13770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13771   void * jresult ;
13772   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13773   float *result = 0 ;
13774
13775   arg1 = (Dali::Matrix3 *)jarg1;
13776   {
13777     try {
13778       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13779     } catch (std::out_of_range& e) {
13780       {
13781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13782       };
13783     } catch (std::exception& e) {
13784       {
13785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13786       };
13787     } catch (Dali::DaliException e) {
13788       {
13789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13790       };
13791     } catch (...) {
13792       {
13793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13794       };
13795     }
13796   }
13797
13798   jresult = (void *)result;
13799   return jresult;
13800 }
13801
13802
13803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13804   unsigned int jresult ;
13805   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13806   bool result;
13807
13808   arg1 = (Dali::Matrix3 *)jarg1;
13809   {
13810     try {
13811       result = (bool)(arg1)->Invert();
13812     } catch (std::out_of_range& e) {
13813       {
13814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13815       };
13816     } catch (std::exception& e) {
13817       {
13818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13819       };
13820     } catch (Dali::DaliException e) {
13821       {
13822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13823       };
13824     } catch (...) {
13825       {
13826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13827       };
13828     }
13829   }
13830
13831   jresult = result;
13832   return jresult;
13833 }
13834
13835
13836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13837   unsigned int jresult ;
13838   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13839   bool result;
13840
13841   arg1 = (Dali::Matrix3 *)jarg1;
13842   {
13843     try {
13844       result = (bool)(arg1)->Transpose();
13845     } catch (std::out_of_range& e) {
13846       {
13847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13848       };
13849     } catch (std::exception& e) {
13850       {
13851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13852       };
13853     } catch (Dali::DaliException e) {
13854       {
13855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13856       };
13857     } catch (...) {
13858       {
13859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13860       };
13861     }
13862   }
13863
13864   jresult = result;
13865   return jresult;
13866 }
13867
13868
13869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13870   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13871   float arg2 ;
13872
13873   arg1 = (Dali::Matrix3 *)jarg1;
13874   arg2 = (float)jarg2;
13875   {
13876     try {
13877       (arg1)->Scale(arg2);
13878     } catch (std::out_of_range& e) {
13879       {
13880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13881       };
13882     } catch (std::exception& e) {
13883       {
13884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13885       };
13886     } catch (Dali::DaliException e) {
13887       {
13888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13889       };
13890     } catch (...) {
13891       {
13892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13893       };
13894     }
13895   }
13896
13897 }
13898
13899
13900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13901   float jresult ;
13902   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13903   float result;
13904
13905   arg1 = (Dali::Matrix3 *)jarg1;
13906   {
13907     try {
13908       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13909     } catch (std::out_of_range& e) {
13910       {
13911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13912       };
13913     } catch (std::exception& e) {
13914       {
13915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13916       };
13917     } catch (Dali::DaliException e) {
13918       {
13919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13920       };
13921     } catch (...) {
13922       {
13923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13924       };
13925     }
13926   }
13927
13928   jresult = result;
13929   return jresult;
13930 }
13931
13932
13933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13934   unsigned int jresult ;
13935   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13936   bool result;
13937
13938   arg1 = (Dali::Matrix3 *)jarg1;
13939   {
13940     try {
13941       result = (bool)(arg1)->ScaledInverseTranspose();
13942     } catch (std::out_of_range& e) {
13943       {
13944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13945       };
13946     } catch (std::exception& e) {
13947       {
13948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13949       };
13950     } catch (Dali::DaliException e) {
13951       {
13952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13953       };
13954     } catch (...) {
13955       {
13956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13957       };
13958     }
13959   }
13960
13961   jresult = result;
13962   return jresult;
13963 }
13964
13965
13966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13967   Dali::Matrix3 *arg1 = 0 ;
13968   Dali::Matrix3 *arg2 = 0 ;
13969   Dali::Matrix3 *arg3 = 0 ;
13970
13971   arg1 = (Dali::Matrix3 *)jarg1;
13972   if (!arg1) {
13973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13974     return ;
13975   }
13976   arg2 = (Dali::Matrix3 *)jarg2;
13977   if (!arg2) {
13978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13979     return ;
13980   }
13981   arg3 = (Dali::Matrix3 *)jarg3;
13982   if (!arg3) {
13983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13984     return ;
13985   }
13986   {
13987     try {
13988       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13989     } catch (std::out_of_range& e) {
13990       {
13991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13992       };
13993     } catch (std::exception& e) {
13994       {
13995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13996       };
13997     } catch (Dali::DaliException e) {
13998       {
13999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14000       };
14001     } catch (...) {
14002       {
14003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14004       };
14005     }
14006   }
14007
14008 }
14009
14010
14011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14012   float jresult ;
14013   float arg1 ;
14014   float arg2 ;
14015   float result;
14016
14017   arg1 = (float)jarg1;
14018   arg2 = (float)jarg2;
14019   {
14020     try {
14021       result = (float)Dali::Random::Range(arg1,arg2);
14022     } catch (std::out_of_range& e) {
14023       {
14024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14025       };
14026     } catch (std::exception& e) {
14027       {
14028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14029       };
14030     } catch (Dali::DaliException e) {
14031       {
14032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14033       };
14034     } catch (...) {
14035       {
14036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14037       };
14038     }
14039   }
14040
14041   jresult = result;
14042   return jresult;
14043 }
14044
14045
14046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14047   void * jresult ;
14048   Dali::Vector4 result;
14049
14050   {
14051     try {
14052       result = Dali::Random::Axis();
14053     } catch (std::out_of_range& e) {
14054       {
14055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14056       };
14057     } catch (std::exception& e) {
14058       {
14059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14060       };
14061     } catch (Dali::DaliException e) {
14062       {
14063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14064       };
14065     } catch (...) {
14066       {
14067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14068       };
14069     }
14070   }
14071
14072   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14073   return jresult;
14074 }
14075
14076
14077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14078   void * jresult ;
14079   Dali::AngleAxis *result = 0 ;
14080
14081   {
14082     try {
14083       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14084     } catch (std::out_of_range& e) {
14085       {
14086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14087       };
14088     } catch (std::exception& e) {
14089       {
14090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14091       };
14092     } catch (Dali::DaliException e) {
14093       {
14094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14095       };
14096     } catch (...) {
14097       {
14098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14099       };
14100     }
14101   }
14102
14103   jresult = (void *)result;
14104   return jresult;
14105 }
14106
14107
14108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14109   void * jresult ;
14110   Dali::Radian arg1 ;
14111   Dali::Vector3 *arg2 = 0 ;
14112   Dali::Radian *argp1 ;
14113   Dali::AngleAxis *result = 0 ;
14114
14115   argp1 = (Dali::Radian *)jarg1;
14116   if (!argp1) {
14117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14118     return 0;
14119   }
14120   arg1 = *argp1;
14121   arg2 = (Dali::Vector3 *)jarg2;
14122   if (!arg2) {
14123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14124     return 0;
14125   }
14126   {
14127     try {
14128       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14129     } catch (std::out_of_range& e) {
14130       {
14131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14132       };
14133     } catch (std::exception& e) {
14134       {
14135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14136       };
14137     } catch (Dali::DaliException e) {
14138       {
14139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14140       };
14141     } catch (...) {
14142       {
14143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14144       };
14145     }
14146   }
14147
14148   jresult = (void *)result;
14149   return jresult;
14150 }
14151
14152
14153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14154   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14155   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14156
14157   arg1 = (Dali::AngleAxis *)jarg1;
14158   arg2 = (Dali::Radian *)jarg2;
14159   if (arg1) (arg1)->angle = *arg2;
14160 }
14161
14162
14163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14164   void * jresult ;
14165   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14166   Dali::Radian *result = 0 ;
14167
14168   arg1 = (Dali::AngleAxis *)jarg1;
14169   result = (Dali::Radian *)& ((arg1)->angle);
14170   jresult = (void *)result;
14171   return jresult;
14172 }
14173
14174
14175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14176   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14177   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14178
14179   arg1 = (Dali::AngleAxis *)jarg1;
14180   arg2 = (Dali::Vector3 *)jarg2;
14181   if (arg1) (arg1)->axis = *arg2;
14182 }
14183
14184
14185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14186   void * jresult ;
14187   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14188   Dali::Vector3 *result = 0 ;
14189
14190   arg1 = (Dali::AngleAxis *)jarg1;
14191   result = (Dali::Vector3 *)& ((arg1)->axis);
14192   jresult = (void *)result;
14193   return jresult;
14194 }
14195
14196
14197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14198   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14199
14200   arg1 = (Dali::AngleAxis *)jarg1;
14201   {
14202     try {
14203       delete arg1;
14204     } catch (std::out_of_range& e) {
14205       {
14206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14207       };
14208     } catch (std::exception& e) {
14209       {
14210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14211       };
14212     } catch (Dali::DaliException e) {
14213       {
14214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14215       };
14216     } catch (...) {
14217       {
14218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14219       };
14220     }
14221   }
14222
14223 }
14224
14225
14226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14227   unsigned int jresult ;
14228   Dali::AngleAxis *arg1 = 0 ;
14229   Dali::AngleAxis *arg2 = 0 ;
14230   bool result;
14231
14232   arg1 = (Dali::AngleAxis *)jarg1;
14233   if (!arg1) {
14234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14235     return 0;
14236   }
14237   arg2 = (Dali::AngleAxis *)jarg2;
14238   if (!arg2) {
14239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14240     return 0;
14241   }
14242   {
14243     try {
14244       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14245     } catch (std::out_of_range& e) {
14246       {
14247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14248       };
14249     } catch (std::exception& e) {
14250       {
14251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14252       };
14253     } catch (Dali::DaliException e) {
14254       {
14255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14256       };
14257     } catch (...) {
14258       {
14259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14260       };
14261     }
14262   }
14263
14264   jresult = result;
14265   return jresult;
14266 }
14267
14268
14269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14270   unsigned int jresult ;
14271   unsigned int arg1 ;
14272   unsigned int result;
14273
14274   arg1 = (unsigned int)jarg1;
14275   {
14276     try {
14277       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14278     } catch (std::out_of_range& e) {
14279       {
14280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14281       };
14282     } catch (std::exception& e) {
14283       {
14284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14285       };
14286     } catch (Dali::DaliException e) {
14287       {
14288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14289       };
14290     } catch (...) {
14291       {
14292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14293       };
14294     }
14295   }
14296
14297   jresult = result;
14298   return jresult;
14299 }
14300
14301
14302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14303   unsigned int jresult ;
14304   unsigned int arg1 ;
14305   bool result;
14306
14307   arg1 = (unsigned int)jarg1;
14308   {
14309     try {
14310       result = (bool)Dali::IsPowerOfTwo(arg1);
14311     } catch (std::out_of_range& e) {
14312       {
14313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14314       };
14315     } catch (std::exception& e) {
14316       {
14317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14318       };
14319     } catch (Dali::DaliException e) {
14320       {
14321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14322       };
14323     } catch (...) {
14324       {
14325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14326       };
14327     }
14328   }
14329
14330   jresult = result;
14331   return jresult;
14332 }
14333
14334
14335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14336   float jresult ;
14337   float arg1 ;
14338   float arg2 ;
14339   float result;
14340
14341   arg1 = (float)jarg1;
14342   arg2 = (float)jarg2;
14343   {
14344     try {
14345       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14346     } catch (std::out_of_range& e) {
14347       {
14348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14349       };
14350     } catch (std::exception& e) {
14351       {
14352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14353       };
14354     } catch (Dali::DaliException e) {
14355       {
14356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14357       };
14358     } catch (...) {
14359       {
14360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14361       };
14362     }
14363   }
14364
14365   jresult = result;
14366   return jresult;
14367 }
14368
14369
14370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14371   unsigned int jresult ;
14372   float arg1 ;
14373   bool result;
14374
14375   arg1 = (float)jarg1;
14376   {
14377     try {
14378       result = (bool)Dali::EqualsZero(arg1);
14379     } catch (std::out_of_range& e) {
14380       {
14381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14382       };
14383     } catch (std::exception& e) {
14384       {
14385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14386       };
14387     } catch (Dali::DaliException e) {
14388       {
14389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14390       };
14391     } catch (...) {
14392       {
14393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14394       };
14395     }
14396   }
14397
14398   jresult = result;
14399   return jresult;
14400 }
14401
14402
14403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14404   unsigned int jresult ;
14405   float arg1 ;
14406   float arg2 ;
14407   bool result;
14408
14409   arg1 = (float)jarg1;
14410   arg2 = (float)jarg2;
14411   {
14412     try {
14413       result = (bool)Dali::Equals(arg1,arg2);
14414     } catch (std::out_of_range& e) {
14415       {
14416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14417       };
14418     } catch (std::exception& e) {
14419       {
14420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14421       };
14422     } catch (Dali::DaliException e) {
14423       {
14424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14425       };
14426     } catch (...) {
14427       {
14428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14429       };
14430     }
14431   }
14432
14433   jresult = result;
14434   return jresult;
14435 }
14436
14437
14438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14439   unsigned int jresult ;
14440   float arg1 ;
14441   float arg2 ;
14442   float arg3 ;
14443   bool result;
14444
14445   arg1 = (float)jarg1;
14446   arg2 = (float)jarg2;
14447   arg3 = (float)jarg3;
14448   {
14449     try {
14450       result = (bool)Dali::Equals(arg1,arg2,arg3);
14451     } catch (std::out_of_range& e) {
14452       {
14453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14454       };
14455     } catch (std::exception& e) {
14456       {
14457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14458       };
14459     } catch (Dali::DaliException e) {
14460       {
14461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14462       };
14463     } catch (...) {
14464       {
14465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14466       };
14467     }
14468   }
14469
14470   jresult = result;
14471   return jresult;
14472 }
14473
14474
14475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14476   float jresult ;
14477   float arg1 ;
14478   int arg2 ;
14479   float result;
14480
14481   arg1 = (float)jarg1;
14482   arg2 = (int)jarg2;
14483   {
14484     try {
14485       result = (float)Dali::Round(arg1,arg2);
14486     } catch (std::out_of_range& e) {
14487       {
14488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14489       };
14490     } catch (std::exception& e) {
14491       {
14492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14493       };
14494     } catch (Dali::DaliException e) {
14495       {
14496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14497       };
14498     } catch (...) {
14499       {
14500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14501       };
14502     }
14503   }
14504
14505   jresult = result;
14506   return jresult;
14507 }
14508
14509
14510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14511   float jresult ;
14512   float arg1 ;
14513   float arg2 ;
14514   float arg3 ;
14515   float result;
14516
14517   arg1 = (float)jarg1;
14518   arg2 = (float)jarg2;
14519   arg3 = (float)jarg3;
14520   {
14521     try {
14522       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14523     } catch (std::out_of_range& e) {
14524       {
14525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14526       };
14527     } catch (std::exception& e) {
14528       {
14529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14530       };
14531     } catch (Dali::DaliException e) {
14532       {
14533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14534       };
14535     } catch (...) {
14536       {
14537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14538       };
14539     }
14540   }
14541
14542   jresult = result;
14543   return jresult;
14544 }
14545
14546
14547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14548   float jresult ;
14549   float arg1 ;
14550   float arg2 ;
14551   float arg3 ;
14552   float arg4 ;
14553   float result;
14554
14555   arg1 = (float)jarg1;
14556   arg2 = (float)jarg2;
14557   arg3 = (float)jarg3;
14558   arg4 = (float)jarg4;
14559   {
14560     try {
14561       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14562     } catch (std::out_of_range& e) {
14563       {
14564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14565       };
14566     } catch (std::exception& e) {
14567       {
14568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14569       };
14570     } catch (Dali::DaliException e) {
14571       {
14572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14573       };
14574     } catch (...) {
14575       {
14576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14577       };
14578     }
14579   }
14580
14581   jresult = result;
14582   return jresult;
14583 }
14584
14585
14586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14587   int jresult ;
14588   int result;
14589
14590   result = (int)(int)Dali::Property::INVALID_INDEX;
14591   jresult = result;
14592   return jresult;
14593 }
14594
14595
14596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14597   int jresult ;
14598   int result;
14599
14600   result = (int)(int)Dali::Property::INVALID_KEY;
14601   jresult = result;
14602   return jresult;
14603 }
14604
14605
14606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14607   int jresult ;
14608   int result;
14609
14610   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14611   jresult = result;
14612   return jresult;
14613 }
14614
14615
14616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14617   void * jresult ;
14618   Dali::Handle *arg1 = 0 ;
14619   Dali::Property::Index arg2 ;
14620   Dali::Property *result = 0 ;
14621
14622   arg1 = (Dali::Handle *)jarg1;
14623   if (!arg1) {
14624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14625     return 0;
14626   }
14627   arg2 = (Dali::Property::Index)jarg2;
14628   {
14629     try {
14630       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14631     } catch (std::out_of_range& e) {
14632       {
14633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14634       };
14635     } catch (std::exception& e) {
14636       {
14637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14638       };
14639     } catch (Dali::DaliException e) {
14640       {
14641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14642       };
14643     } catch (...) {
14644       {
14645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14646       };
14647     }
14648   }
14649
14650   jresult = (void *)result;
14651   return jresult;
14652 }
14653
14654
14655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14656   void * jresult ;
14657   Dali::Handle *arg1 = 0 ;
14658   Dali::Property::Index arg2 ;
14659   int arg3 ;
14660   Dali::Property *result = 0 ;
14661
14662   arg1 = (Dali::Handle *)jarg1;
14663   if (!arg1) {
14664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14665     return 0;
14666   }
14667   arg2 = (Dali::Property::Index)jarg2;
14668   arg3 = (int)jarg3;
14669   {
14670     try {
14671       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14672     } catch (std::out_of_range& e) {
14673       {
14674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14675       };
14676     } catch (std::exception& e) {
14677       {
14678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14679       };
14680     } catch (Dali::DaliException e) {
14681       {
14682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14683       };
14684     } catch (...) {
14685       {
14686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14687       };
14688     }
14689   }
14690
14691   jresult = (void *)result;
14692   return jresult;
14693 }
14694
14695
14696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14697   void * jresult ;
14698   Dali::Handle *arg1 = 0 ;
14699   std::string *arg2 = 0 ;
14700   Dali::Property *result = 0 ;
14701
14702   arg1 = (Dali::Handle *)jarg1;
14703   if (!arg1) {
14704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14705     return 0;
14706   }
14707   if (!jarg2) {
14708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14709     return 0;
14710   }
14711   std::string arg2_str(jarg2);
14712   arg2 = &arg2_str;
14713   {
14714     try {
14715       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14716     } catch (std::out_of_range& e) {
14717       {
14718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14719       };
14720     } catch (std::exception& e) {
14721       {
14722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14723       };
14724     } catch (Dali::DaliException e) {
14725       {
14726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14727       };
14728     } catch (...) {
14729       {
14730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14731       };
14732     }
14733   }
14734
14735   jresult = (void *)result;
14736
14737   //argout typemap for const std::string&
14738
14739   return jresult;
14740 }
14741
14742
14743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14744   void * jresult ;
14745   Dali::Handle *arg1 = 0 ;
14746   std::string *arg2 = 0 ;
14747   int arg3 ;
14748   Dali::Property *result = 0 ;
14749
14750   arg1 = (Dali::Handle *)jarg1;
14751   if (!arg1) {
14752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14753     return 0;
14754   }
14755   if (!jarg2) {
14756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14757     return 0;
14758   }
14759   std::string arg2_str(jarg2);
14760   arg2 = &arg2_str;
14761   arg3 = (int)jarg3;
14762   {
14763     try {
14764       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14765     } catch (std::out_of_range& e) {
14766       {
14767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14768       };
14769     } catch (std::exception& e) {
14770       {
14771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14772       };
14773     } catch (Dali::DaliException e) {
14774       {
14775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14776       };
14777     } catch (...) {
14778       {
14779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14780       };
14781     }
14782   }
14783
14784   jresult = (void *)result;
14785
14786   //argout typemap for const std::string&
14787
14788   return jresult;
14789 }
14790
14791
14792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14793   Dali::Property *arg1 = (Dali::Property *) 0 ;
14794
14795   arg1 = (Dali::Property *)jarg1;
14796   {
14797     try {
14798       delete arg1;
14799     } catch (std::out_of_range& e) {
14800       {
14801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14802       };
14803     } catch (std::exception& e) {
14804       {
14805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14806       };
14807     } catch (Dali::DaliException e) {
14808       {
14809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14810       };
14811     } catch (...) {
14812       {
14813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14814       };
14815     }
14816   }
14817
14818 }
14819
14820
14821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14822   Dali::Property *arg1 = (Dali::Property *) 0 ;
14823   Dali::Handle *arg2 = 0 ;
14824
14825   arg1 = (Dali::Property *)jarg1;
14826   arg2 = (Dali::Handle *)jarg2;
14827   if (!arg2) {
14828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14829     return ;
14830   }
14831   if (arg1) (arg1)->object = *arg2;
14832 }
14833
14834
14835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14836   void * jresult ;
14837   Dali::Property *arg1 = (Dali::Property *) 0 ;
14838   Dali::Handle *result = 0 ;
14839
14840   arg1 = (Dali::Property *)jarg1;
14841   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14842   jresult = (void *)result;
14843   return jresult;
14844 }
14845
14846
14847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14848   Dali::Property *arg1 = (Dali::Property *) 0 ;
14849   Dali::Property::Index arg2 ;
14850
14851   arg1 = (Dali::Property *)jarg1;
14852   arg2 = (Dali::Property::Index)jarg2;
14853   if (arg1) (arg1)->propertyIndex = arg2;
14854 }
14855
14856
14857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14858   int jresult ;
14859   Dali::Property *arg1 = (Dali::Property *) 0 ;
14860   Dali::Property::Index result;
14861
14862   arg1 = (Dali::Property *)jarg1;
14863   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14864   jresult = result;
14865   return jresult;
14866 }
14867
14868
14869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14870   Dali::Property *arg1 = (Dali::Property *) 0 ;
14871   int arg2 ;
14872
14873   arg1 = (Dali::Property *)jarg1;
14874   arg2 = (int)jarg2;
14875   if (arg1) (arg1)->componentIndex = arg2;
14876 }
14877
14878
14879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14880   int jresult ;
14881   Dali::Property *arg1 = (Dali::Property *) 0 ;
14882   int result;
14883
14884   arg1 = (Dali::Property *)jarg1;
14885   result = (int) ((arg1)->componentIndex);
14886   jresult = result;
14887   return jresult;
14888 }
14889
14890
14891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14892   void * jresult ;
14893   Dali::Property::Array *result = 0 ;
14894
14895   {
14896     try {
14897       result = (Dali::Property::Array *)new Dali::Property::Array();
14898     } catch (std::out_of_range& e) {
14899       {
14900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14901       };
14902     } catch (std::exception& e) {
14903       {
14904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14905       };
14906     } catch (Dali::DaliException e) {
14907       {
14908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14909       };
14910     } catch (...) {
14911       {
14912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14913       };
14914     }
14915   }
14916
14917   jresult = (void *)result;
14918   return jresult;
14919 }
14920
14921
14922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14923   void * jresult ;
14924   Dali::Property::Array *arg1 = 0 ;
14925   Dali::Property::Array *result = 0 ;
14926
14927   arg1 = (Dali::Property::Array *)jarg1;
14928   if (!arg1) {
14929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14930     return 0;
14931   }
14932   {
14933     try {
14934       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14935     } catch (std::out_of_range& e) {
14936       {
14937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14938       };
14939     } catch (std::exception& e) {
14940       {
14941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14942       };
14943     } catch (Dali::DaliException e) {
14944       {
14945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14946       };
14947     } catch (...) {
14948       {
14949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14950       };
14951     }
14952   }
14953
14954   jresult = (void *)result;
14955   return jresult;
14956 }
14957
14958
14959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14960   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14961
14962   arg1 = (Dali::Property::Array *)jarg1;
14963   {
14964     try {
14965       delete arg1;
14966     } catch (std::out_of_range& e) {
14967       {
14968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14969       };
14970     } catch (std::exception& e) {
14971       {
14972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14973       };
14974     } catch (Dali::DaliException e) {
14975       {
14976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14977       };
14978     } catch (...) {
14979       {
14980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14981       };
14982     }
14983   }
14984
14985 }
14986
14987
14988 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14989   unsigned long jresult ;
14990   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14991   Dali::Property::Array::SizeType result;
14992
14993   arg1 = (Dali::Property::Array *)jarg1;
14994   {
14995     try {
14996       result = ((Dali::Property::Array const *)arg1)->Size();
14997     } catch (std::out_of_range& e) {
14998       {
14999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15000       };
15001     } catch (std::exception& e) {
15002       {
15003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15004       };
15005     } catch (Dali::DaliException e) {
15006       {
15007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15008       };
15009     } catch (...) {
15010       {
15011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15012       };
15013     }
15014   }
15015
15016   jresult = (unsigned long)result;
15017   return jresult;
15018 }
15019
15020
15021 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15022   unsigned long jresult ;
15023   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15024   Dali::Property::Array::SizeType result;
15025
15026   arg1 = (Dali::Property::Array *)jarg1;
15027   {
15028     try {
15029       result = ((Dali::Property::Array const *)arg1)->Count();
15030     } catch (std::out_of_range& e) {
15031       {
15032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15033       };
15034     } catch (std::exception& e) {
15035       {
15036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15037       };
15038     } catch (Dali::DaliException e) {
15039       {
15040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15041       };
15042     } catch (...) {
15043       {
15044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15045       };
15046     }
15047   }
15048
15049   jresult = (unsigned long)result;
15050   return jresult;
15051 }
15052
15053
15054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15055   unsigned int jresult ;
15056   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15057   bool result;
15058
15059   arg1 = (Dali::Property::Array *)jarg1;
15060   {
15061     try {
15062       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15063     } catch (std::out_of_range& e) {
15064       {
15065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15066       };
15067     } catch (std::exception& e) {
15068       {
15069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15070       };
15071     } catch (Dali::DaliException e) {
15072       {
15073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15074       };
15075     } catch (...) {
15076       {
15077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15078       };
15079     }
15080   }
15081
15082   jresult = result;
15083   return jresult;
15084 }
15085
15086
15087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15088   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15089
15090   arg1 = (Dali::Property::Array *)jarg1;
15091   {
15092     try {
15093       (arg1)->Clear();
15094     } catch (std::out_of_range& e) {
15095       {
15096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15097       };
15098     } catch (std::exception& e) {
15099       {
15100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15101       };
15102     } catch (Dali::DaliException e) {
15103       {
15104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15105       };
15106     } catch (...) {
15107       {
15108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15109       };
15110     }
15111   }
15112
15113 }
15114
15115
15116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15117   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15118   Dali::Property::Array::SizeType arg2 ;
15119
15120   arg1 = (Dali::Property::Array *)jarg1;
15121   arg2 = (Dali::Property::Array::SizeType)jarg2;
15122   {
15123     try {
15124       (arg1)->Reserve(arg2);
15125     } catch (std::out_of_range& e) {
15126       {
15127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15128       };
15129     } catch (std::exception& e) {
15130       {
15131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15132       };
15133     } catch (Dali::DaliException e) {
15134       {
15135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15136       };
15137     } catch (...) {
15138       {
15139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15140       };
15141     }
15142   }
15143
15144 }
15145
15146
15147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15148   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15149   Dali::Property::Array::SizeType arg2 ;
15150
15151   arg1 = (Dali::Property::Array *)jarg1;
15152   arg2 = (Dali::Property::Array::SizeType)jarg2;
15153   {
15154     try {
15155       (arg1)->Resize(arg2);
15156     } catch (std::out_of_range& e) {
15157       {
15158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15159       };
15160     } catch (std::exception& e) {
15161       {
15162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15163       };
15164     } catch (Dali::DaliException e) {
15165       {
15166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15167       };
15168     } catch (...) {
15169       {
15170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15171       };
15172     }
15173   }
15174
15175 }
15176
15177
15178 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15179   unsigned long jresult ;
15180   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15181   Dali::Property::Array::SizeType result;
15182
15183   arg1 = (Dali::Property::Array *)jarg1;
15184   {
15185     try {
15186       result = (arg1)->Capacity();
15187     } catch (std::out_of_range& e) {
15188       {
15189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15190       };
15191     } catch (std::exception& e) {
15192       {
15193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15194       };
15195     } catch (Dali::DaliException e) {
15196       {
15197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15198       };
15199     } catch (...) {
15200       {
15201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15202       };
15203     }
15204   }
15205
15206   jresult = (unsigned long)result;
15207   return jresult;
15208 }
15209
15210
15211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15212   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15213   Dali::Property::Value *arg2 = 0 ;
15214
15215   arg1 = (Dali::Property::Array *)jarg1;
15216   arg2 = (Dali::Property::Value *)jarg2;
15217   if (!arg2) {
15218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15219     return ;
15220   }
15221   {
15222     try {
15223       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15224     } catch (std::out_of_range& e) {
15225       {
15226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15227       };
15228     } catch (std::exception& e) {
15229       {
15230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15231       };
15232     } catch (Dali::DaliException e) {
15233       {
15234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15235       };
15236     } catch (...) {
15237       {
15238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15239       };
15240     }
15241   }
15242
15243 }
15244
15245
15246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15247   void * jresult ;
15248   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15249   Dali::Property::Value *arg2 = 0 ;
15250   Dali::Property::Array *result = 0 ;
15251
15252   arg1 = (Dali::Property::Array *)jarg1;
15253   arg2 = (Dali::Property::Value *)jarg2;
15254   if (!arg2) {
15255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15256     return 0;
15257   }
15258   {
15259     try {
15260       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15261     } catch (std::out_of_range& e) {
15262       {
15263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15264       };
15265     } catch (std::exception& e) {
15266       {
15267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15268       };
15269     } catch (Dali::DaliException e) {
15270       {
15271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15272       };
15273     } catch (...) {
15274       {
15275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15276       };
15277     }
15278   }
15279
15280   jresult = (void *)result;
15281   return jresult;
15282 }
15283
15284
15285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15286   void * jresult ;
15287   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15288   Dali::Property::Array::SizeType arg2 ;
15289   Dali::Property::Value *result = 0 ;
15290
15291   arg1 = (Dali::Property::Array *)jarg1;
15292   arg2 = (Dali::Property::Array::SizeType)jarg2;
15293   {
15294     try {
15295       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15296     } catch (std::out_of_range& e) {
15297       {
15298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15299       };
15300     } catch (std::exception& e) {
15301       {
15302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15303       };
15304     } catch (Dali::DaliException e) {
15305       {
15306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15307       };
15308     } catch (...) {
15309       {
15310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15311       };
15312     }
15313   }
15314
15315   jresult = (void *)result;
15316   return jresult;
15317 }
15318
15319
15320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15321   void * jresult ;
15322   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15323   Dali::Property::Array::SizeType arg2 ;
15324   Dali::Property::Value *result = 0 ;
15325
15326   arg1 = (Dali::Property::Array *)jarg1;
15327   arg2 = (Dali::Property::Array::SizeType)jarg2;
15328   {
15329     try {
15330       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15331     } catch (std::out_of_range& e) {
15332       {
15333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15334       };
15335     } catch (std::exception& e) {
15336       {
15337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15338       };
15339     } catch (Dali::DaliException e) {
15340       {
15341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15342       };
15343     } catch (...) {
15344       {
15345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15346       };
15347     }
15348   }
15349
15350   jresult = (void *)result;
15351   return jresult;
15352 }
15353
15354
15355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15356   void * jresult ;
15357   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15358   Dali::Property::Array *arg2 = 0 ;
15359   Dali::Property::Array *result = 0 ;
15360
15361   arg1 = (Dali::Property::Array *)jarg1;
15362   arg2 = (Dali::Property::Array *)jarg2;
15363   if (!arg2) {
15364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15365     return 0;
15366   }
15367   {
15368     try {
15369       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15370     } catch (std::out_of_range& e) {
15371       {
15372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15373       };
15374     } catch (std::exception& e) {
15375       {
15376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15377       };
15378     } catch (Dali::DaliException e) {
15379       {
15380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15381       };
15382     } catch (...) {
15383       {
15384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15385       };
15386     }
15387   }
15388
15389   jresult = (void *)result;
15390   return jresult;
15391 }
15392
15393
15394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15395   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15396   enum Dali::Property::Key::Type arg2 ;
15397
15398   arg1 = (Dali::Property::Key *)jarg1;
15399   arg2 = (enum Dali::Property::Key::Type)jarg2;
15400   if (arg1) (arg1)->type = arg2;
15401 }
15402
15403
15404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15405   int jresult ;
15406   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15407   enum Dali::Property::Key::Type result;
15408
15409   arg1 = (Dali::Property::Key *)jarg1;
15410   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15411   jresult = (int)result;
15412   return jresult;
15413 }
15414
15415
15416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15417   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15418   Dali::Property::Index arg2 ;
15419
15420   arg1 = (Dali::Property::Key *)jarg1;
15421   arg2 = (Dali::Property::Index)jarg2;
15422   if (arg1) (arg1)->indexKey = arg2;
15423 }
15424
15425
15426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15427   int jresult ;
15428   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15429   Dali::Property::Index result;
15430
15431   arg1 = (Dali::Property::Key *)jarg1;
15432   result = (Dali::Property::Index) ((arg1)->indexKey);
15433   jresult = result;
15434   return jresult;
15435 }
15436
15437
15438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15439   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15440   std::string *arg2 = 0 ;
15441
15442   arg1 = (Dali::Property::Key *)jarg1;
15443   if (!jarg2) {
15444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15445     return ;
15446   }
15447   std::string arg2_str(jarg2);
15448   arg2 = &arg2_str;
15449   if (arg1) (arg1)->stringKey = *arg2;
15450
15451   //argout typemap for const std::string&
15452
15453 }
15454
15455
15456 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15457   char * jresult ;
15458   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15459   std::string *result = 0 ;
15460
15461   arg1 = (Dali::Property::Key *)jarg1;
15462   result = (std::string *) & ((arg1)->stringKey);
15463   jresult = SWIG_csharp_string_callback(result->c_str());
15464   return jresult;
15465 }
15466
15467
15468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15469   void * jresult ;
15470   std::string *arg1 = 0 ;
15471   Dali::Property::Key *result = 0 ;
15472
15473   if (!jarg1) {
15474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15475     return 0;
15476   }
15477   std::string arg1_str(jarg1);
15478   arg1 = &arg1_str;
15479   {
15480     try {
15481       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15482     } catch (std::out_of_range& e) {
15483       {
15484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15485       };
15486     } catch (std::exception& e) {
15487       {
15488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15489       };
15490     } catch (Dali::DaliException e) {
15491       {
15492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15493       };
15494     } catch (...) {
15495       {
15496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15497       };
15498     }
15499   }
15500
15501   jresult = (void *)result;
15502
15503   //argout typemap for const std::string&
15504
15505   return jresult;
15506 }
15507
15508
15509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15510   void * jresult ;
15511   Dali::Property::Index arg1 ;
15512   Dali::Property::Key *result = 0 ;
15513
15514   arg1 = (Dali::Property::Index)jarg1;
15515   {
15516     try {
15517       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15518     } catch (std::out_of_range& e) {
15519       {
15520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15521       };
15522     } catch (std::exception& e) {
15523       {
15524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15525       };
15526     } catch (Dali::DaliException e) {
15527       {
15528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15529       };
15530     } catch (...) {
15531       {
15532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15533       };
15534     }
15535   }
15536
15537   jresult = (void *)result;
15538   return jresult;
15539 }
15540
15541
15542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15543   unsigned int jresult ;
15544   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15545   std::string *arg2 = 0 ;
15546   bool result;
15547
15548   arg1 = (Dali::Property::Key *)jarg1;
15549   if (!jarg2) {
15550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15551     return 0;
15552   }
15553   std::string arg2_str(jarg2);
15554   arg2 = &arg2_str;
15555   {
15556     try {
15557       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15558     } catch (std::out_of_range& e) {
15559       {
15560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15561       };
15562     } catch (std::exception& e) {
15563       {
15564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15565       };
15566     } catch (Dali::DaliException e) {
15567       {
15568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15569       };
15570     } catch (...) {
15571       {
15572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15573       };
15574     }
15575   }
15576
15577   jresult = result;
15578
15579   //argout typemap for const std::string&
15580
15581   return jresult;
15582 }
15583
15584
15585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15586   unsigned int jresult ;
15587   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15588   Dali::Property::Index arg2 ;
15589   bool result;
15590
15591   arg1 = (Dali::Property::Key *)jarg1;
15592   arg2 = (Dali::Property::Index)jarg2;
15593   {
15594     try {
15595       result = (bool)(arg1)->operator ==(arg2);
15596     } catch (std::out_of_range& e) {
15597       {
15598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15599       };
15600     } catch (std::exception& e) {
15601       {
15602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15603       };
15604     } catch (Dali::DaliException e) {
15605       {
15606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15607       };
15608     } catch (...) {
15609       {
15610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15611       };
15612     }
15613   }
15614
15615   jresult = result;
15616   return jresult;
15617 }
15618
15619
15620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15621   unsigned int jresult ;
15622   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15623   Dali::Property::Key *arg2 = 0 ;
15624   bool result;
15625
15626   arg1 = (Dali::Property::Key *)jarg1;
15627   arg2 = (Dali::Property::Key *)jarg2;
15628   if (!arg2) {
15629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15630     return 0;
15631   }
15632   {
15633     try {
15634       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15635     } catch (std::out_of_range& e) {
15636       {
15637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15638       };
15639     } catch (std::exception& e) {
15640       {
15641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15642       };
15643     } catch (Dali::DaliException e) {
15644       {
15645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15646       };
15647     } catch (...) {
15648       {
15649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15650       };
15651     }
15652   }
15653
15654   jresult = result;
15655   return jresult;
15656 }
15657
15658
15659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15660   unsigned int jresult ;
15661   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15662   std::string *arg2 = 0 ;
15663   bool result;
15664
15665   arg1 = (Dali::Property::Key *)jarg1;
15666   if (!jarg2) {
15667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15668     return 0;
15669   }
15670   std::string arg2_str(jarg2);
15671   arg2 = &arg2_str;
15672   {
15673     try {
15674       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15675     } catch (std::out_of_range& e) {
15676       {
15677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15678       };
15679     } catch (std::exception& e) {
15680       {
15681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15682       };
15683     } catch (Dali::DaliException e) {
15684       {
15685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15686       };
15687     } catch (...) {
15688       {
15689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15690       };
15691     }
15692   }
15693
15694   jresult = result;
15695
15696   //argout typemap for const std::string&
15697
15698   return jresult;
15699 }
15700
15701
15702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15703   unsigned int jresult ;
15704   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15705   Dali::Property::Index arg2 ;
15706   bool result;
15707
15708   arg1 = (Dali::Property::Key *)jarg1;
15709   arg2 = (Dali::Property::Index)jarg2;
15710   {
15711     try {
15712       result = (bool)(arg1)->operator !=(arg2);
15713     } catch (std::out_of_range& e) {
15714       {
15715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15716       };
15717     } catch (std::exception& e) {
15718       {
15719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15720       };
15721     } catch (Dali::DaliException e) {
15722       {
15723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15724       };
15725     } catch (...) {
15726       {
15727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15728       };
15729     }
15730   }
15731
15732   jresult = result;
15733   return jresult;
15734 }
15735
15736
15737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15738   unsigned int jresult ;
15739   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15740   Dali::Property::Key *arg2 = 0 ;
15741   bool result;
15742
15743   arg1 = (Dali::Property::Key *)jarg1;
15744   arg2 = (Dali::Property::Key *)jarg2;
15745   if (!arg2) {
15746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15747     return 0;
15748   }
15749   {
15750     try {
15751       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15752     } catch (std::out_of_range& e) {
15753       {
15754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15755       };
15756     } catch (std::exception& e) {
15757       {
15758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15759       };
15760     } catch (Dali::DaliException e) {
15761       {
15762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15763       };
15764     } catch (...) {
15765       {
15766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15767       };
15768     }
15769   }
15770
15771   jresult = result;
15772   return jresult;
15773 }
15774
15775
15776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15777   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15778
15779   arg1 = (Dali::Property::Key *)jarg1;
15780   {
15781     try {
15782       delete arg1;
15783     } catch (std::out_of_range& e) {
15784       {
15785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15786       };
15787     } catch (std::exception& e) {
15788       {
15789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15790       };
15791     } catch (Dali::DaliException e) {
15792       {
15793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15794       };
15795     } catch (...) {
15796       {
15797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15798       };
15799     }
15800   }
15801
15802 }
15803
15804
15805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15806   void * jresult ;
15807   Dali::Property::Map *result = 0 ;
15808
15809   {
15810     try {
15811       result = (Dali::Property::Map *)new Dali::Property::Map();
15812     } catch (std::out_of_range& e) {
15813       {
15814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15815       };
15816     } catch (std::exception& e) {
15817       {
15818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15819       };
15820     } catch (Dali::DaliException e) {
15821       {
15822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15823       };
15824     } catch (...) {
15825       {
15826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15827       };
15828     }
15829   }
15830
15831   jresult = (void *)result;
15832   return jresult;
15833 }
15834
15835
15836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15837   void * jresult ;
15838   Dali::Property::Map *arg1 = 0 ;
15839   Dali::Property::Map *result = 0 ;
15840
15841   arg1 = (Dali::Property::Map *)jarg1;
15842   if (!arg1) {
15843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15844     return 0;
15845   }
15846   {
15847     try {
15848       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15849     } catch (std::out_of_range& e) {
15850       {
15851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15852       };
15853     } catch (std::exception& e) {
15854       {
15855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15856       };
15857     } catch (Dali::DaliException e) {
15858       {
15859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15860       };
15861     } catch (...) {
15862       {
15863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15864       };
15865     }
15866   }
15867
15868   jresult = (void *)result;
15869   return jresult;
15870 }
15871
15872
15873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15874   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15875
15876   arg1 = (Dali::Property::Map *)jarg1;
15877   {
15878     try {
15879       delete arg1;
15880     } catch (std::out_of_range& e) {
15881       {
15882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15883       };
15884     } catch (std::exception& e) {
15885       {
15886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15887       };
15888     } catch (Dali::DaliException e) {
15889       {
15890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15891       };
15892     } catch (...) {
15893       {
15894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15895       };
15896     }
15897   }
15898
15899 }
15900
15901
15902 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15903   unsigned long jresult ;
15904   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15905   Dali::Property::Map::SizeType result;
15906
15907   arg1 = (Dali::Property::Map *)jarg1;
15908   {
15909     try {
15910       result = ((Dali::Property::Map const *)arg1)->Count();
15911     } catch (std::out_of_range& e) {
15912       {
15913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15914       };
15915     } catch (std::exception& e) {
15916       {
15917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15918       };
15919     } catch (Dali::DaliException e) {
15920       {
15921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15922       };
15923     } catch (...) {
15924       {
15925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15926       };
15927     }
15928   }
15929
15930   jresult = (unsigned long)result;
15931   return jresult;
15932 }
15933
15934
15935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15936   unsigned int jresult ;
15937   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15938   bool result;
15939
15940   arg1 = (Dali::Property::Map *)jarg1;
15941   {
15942     try {
15943       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15944     } catch (std::out_of_range& e) {
15945       {
15946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15947       };
15948     } catch (std::exception& e) {
15949       {
15950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15951       };
15952     } catch (Dali::DaliException e) {
15953       {
15954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15955       };
15956     } catch (...) {
15957       {
15958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15959       };
15960     }
15961   }
15962
15963   jresult = result;
15964   return jresult;
15965 }
15966
15967
15968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15969   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15970   char *arg2 = (char *) 0 ;
15971   Dali::Property::Value *arg3 = 0 ;
15972
15973   arg1 = (Dali::Property::Map *)jarg1;
15974   arg2 = (char *)jarg2;
15975   arg3 = (Dali::Property::Value *)jarg3;
15976   if (!arg3) {
15977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15978     return ;
15979   }
15980   {
15981     try {
15982       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15983     } catch (std::out_of_range& e) {
15984       {
15985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15986       };
15987     } catch (std::exception& e) {
15988       {
15989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15990       };
15991     } catch (Dali::DaliException e) {
15992       {
15993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15994       };
15995     } catch (...) {
15996       {
15997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15998       };
15999     }
16000   }
16001
16002 }
16003
16004
16005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16006   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16007   Dali::Property::Index arg2 ;
16008   Dali::Property::Value *arg3 = 0 ;
16009
16010   arg1 = (Dali::Property::Map *)jarg1;
16011   arg2 = (Dali::Property::Index)jarg2;
16012   arg3 = (Dali::Property::Value *)jarg3;
16013   if (!arg3) {
16014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16015     return ;
16016   }
16017   {
16018     try {
16019       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16020     } catch (std::out_of_range& e) {
16021       {
16022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16023       };
16024     } catch (std::exception& e) {
16025       {
16026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16027       };
16028     } catch (Dali::DaliException e) {
16029       {
16030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16031       };
16032     } catch (...) {
16033       {
16034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16035       };
16036     }
16037   }
16038
16039 }
16040
16041
16042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16043   void * jresult ;
16044   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16045   char *arg2 = (char *) 0 ;
16046   Dali::Property::Value *arg3 = 0 ;
16047   Dali::Property::Map *result = 0 ;
16048
16049   arg1 = (Dali::Property::Map *)jarg1;
16050   arg2 = (char *)jarg2;
16051   arg3 = (Dali::Property::Value *)jarg3;
16052   if (!arg3) {
16053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16054     return 0;
16055   }
16056   {
16057     try {
16058       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16059     } catch (std::out_of_range& e) {
16060       {
16061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16062       };
16063     } catch (std::exception& e) {
16064       {
16065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16066       };
16067     } catch (Dali::DaliException e) {
16068       {
16069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16070       };
16071     } catch (...) {
16072       {
16073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16074       };
16075     }
16076   }
16077
16078   jresult = (void *)result;
16079   return jresult;
16080 }
16081
16082
16083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16084   void * jresult ;
16085   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16086   Dali::Property::Index arg2 ;
16087   Dali::Property::Value *arg3 = 0 ;
16088   Dali::Property::Map *result = 0 ;
16089
16090   arg1 = (Dali::Property::Map *)jarg1;
16091   arg2 = (Dali::Property::Index)jarg2;
16092   arg3 = (Dali::Property::Value *)jarg3;
16093   if (!arg3) {
16094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16095     return 0;
16096   }
16097   {
16098     try {
16099       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16100     } catch (std::out_of_range& e) {
16101       {
16102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16103       };
16104     } catch (std::exception& e) {
16105       {
16106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16107       };
16108     } catch (Dali::DaliException e) {
16109       {
16110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16111       };
16112     } catch (...) {
16113       {
16114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16115       };
16116     }
16117   }
16118
16119   jresult = (void *)result;
16120   return jresult;
16121 }
16122
16123
16124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16125   void * jresult ;
16126   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16127   Dali::Property::Map::SizeType arg2 ;
16128   Dali::Property::Value *result = 0 ;
16129
16130   arg1 = (Dali::Property::Map *)jarg1;
16131   arg2 = (Dali::Property::Map::SizeType)jarg2;
16132   {
16133     try {
16134       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16135     } catch (std::out_of_range& e) {
16136       {
16137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16138       };
16139     } catch (std::exception& e) {
16140       {
16141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16142       };
16143     } catch (Dali::DaliException e) {
16144       {
16145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16146       };
16147     } catch (...) {
16148       {
16149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16150       };
16151     }
16152   }
16153
16154   jresult = (void *)result;
16155   return jresult;
16156 }
16157
16158
16159 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16160   char * jresult ;
16161   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16162   Dali::Property::Map::SizeType arg2 ;
16163   std::string *result = 0 ;
16164
16165   arg1 = (Dali::Property::Map *)jarg1;
16166   arg2 = (Dali::Property::Map::SizeType)jarg2;
16167   {
16168     try {
16169       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16170     } catch (std::out_of_range& e) {
16171       {
16172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16173       };
16174     } catch (std::exception& e) {
16175       {
16176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16177       };
16178     } catch (Dali::DaliException e) {
16179       {
16180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16181       };
16182     } catch (...) {
16183       {
16184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16185       };
16186     }
16187   }
16188
16189   jresult = SWIG_csharp_string_callback(result->c_str());
16190   return jresult;
16191 }
16192
16193
16194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16195   void * jresult ;
16196   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16197   Dali::Property::Map::SizeType arg2 ;
16198   SwigValueWrapper< Dali::Property::Key > result;
16199
16200   arg1 = (Dali::Property::Map *)jarg1;
16201   arg2 = (Dali::Property::Map::SizeType)jarg2;
16202   {
16203     try {
16204       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16205     } catch (std::out_of_range& e) {
16206       {
16207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16208       };
16209     } catch (std::exception& e) {
16210       {
16211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16212       };
16213     } catch (Dali::DaliException e) {
16214       {
16215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16216       };
16217     } catch (...) {
16218       {
16219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16220       };
16221     }
16222   }
16223
16224   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16225   return jresult;
16226 }
16227
16228
16229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16230   void * jresult ;
16231   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16232   Dali::Property::Map::SizeType arg2 ;
16233   StringValuePair *result = 0 ;
16234
16235   arg1 = (Dali::Property::Map *)jarg1;
16236   arg2 = (Dali::Property::Map::SizeType)jarg2;
16237   {
16238     try {
16239       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16240     } catch (std::out_of_range& e) {
16241       {
16242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16243       };
16244     } catch (std::exception& e) {
16245       {
16246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16247       };
16248     } catch (Dali::DaliException e) {
16249       {
16250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16251       };
16252     } catch (...) {
16253       {
16254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16255       };
16256     }
16257   }
16258
16259   jresult = (void *)result;
16260   return jresult;
16261 }
16262
16263
16264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16265   void * jresult ;
16266   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16267   char *arg2 = (char *) 0 ;
16268   Dali::Property::Value *result = 0 ;
16269
16270   arg1 = (Dali::Property::Map *)jarg1;
16271   arg2 = (char *)jarg2;
16272   {
16273     try {
16274       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16275     } catch (std::out_of_range& e) {
16276       {
16277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16278       };
16279     } catch (std::exception& e) {
16280       {
16281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16282       };
16283     } catch (Dali::DaliException e) {
16284       {
16285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16286       };
16287     } catch (...) {
16288       {
16289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16290       };
16291     }
16292   }
16293
16294   jresult = (void *)result;
16295   return jresult;
16296 }
16297
16298
16299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16300   void * jresult ;
16301   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16302   Dali::Property::Index arg2 ;
16303   Dali::Property::Value *result = 0 ;
16304
16305   arg1 = (Dali::Property::Map *)jarg1;
16306   arg2 = (Dali::Property::Index)jarg2;
16307   {
16308     try {
16309       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16310     } catch (std::out_of_range& e) {
16311       {
16312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16313       };
16314     } catch (std::exception& e) {
16315       {
16316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16317       };
16318     } catch (Dali::DaliException e) {
16319       {
16320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16321       };
16322     } catch (...) {
16323       {
16324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16325       };
16326     }
16327   }
16328
16329   jresult = (void *)result;
16330   return jresult;
16331 }
16332
16333
16334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16335   void * jresult ;
16336   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16337   Dali::Property::Index arg2 ;
16338   std::string *arg3 = 0 ;
16339   Dali::Property::Value *result = 0 ;
16340
16341   arg1 = (Dali::Property::Map *)jarg1;
16342   arg2 = (Dali::Property::Index)jarg2;
16343   if (!jarg3) {
16344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16345     return 0;
16346   }
16347   std::string arg3_str(jarg3);
16348   arg3 = &arg3_str;
16349   {
16350     try {
16351       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16352     } catch (std::out_of_range& e) {
16353       {
16354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16355       };
16356     } catch (std::exception& e) {
16357       {
16358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16359       };
16360     } catch (Dali::DaliException e) {
16361       {
16362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16363       };
16364     } catch (...) {
16365       {
16366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16367       };
16368     }
16369   }
16370
16371   jresult = (void *)result;
16372
16373   //argout typemap for const std::string&
16374
16375   return jresult;
16376 }
16377
16378
16379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16380   void * jresult ;
16381   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16382   std::string *arg2 = 0 ;
16383   Dali::Property::Type arg3 ;
16384   Dali::Property::Value *result = 0 ;
16385
16386   arg1 = (Dali::Property::Map *)jarg1;
16387   if (!jarg2) {
16388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16389     return 0;
16390   }
16391   std::string arg2_str(jarg2);
16392   arg2 = &arg2_str;
16393   arg3 = (Dali::Property::Type)jarg3;
16394   {
16395     try {
16396       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16397     } catch (std::out_of_range& e) {
16398       {
16399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16400       };
16401     } catch (std::exception& e) {
16402       {
16403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16404       };
16405     } catch (Dali::DaliException e) {
16406       {
16407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16408       };
16409     } catch (...) {
16410       {
16411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16412       };
16413     }
16414   }
16415
16416   jresult = (void *)result;
16417
16418   //argout typemap for const std::string&
16419
16420   return jresult;
16421 }
16422
16423
16424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16425   void * jresult ;
16426   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16427   Dali::Property::Index arg2 ;
16428   Dali::Property::Type arg3 ;
16429   Dali::Property::Value *result = 0 ;
16430
16431   arg1 = (Dali::Property::Map *)jarg1;
16432   arg2 = (Dali::Property::Index)jarg2;
16433   arg3 = (Dali::Property::Type)jarg3;
16434   {
16435     try {
16436       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16437     } catch (std::out_of_range& e) {
16438       {
16439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16440       };
16441     } catch (std::exception& e) {
16442       {
16443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16444       };
16445     } catch (Dali::DaliException e) {
16446       {
16447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16448       };
16449     } catch (...) {
16450       {
16451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16452       };
16453     }
16454   }
16455
16456   jresult = (void *)result;
16457   return jresult;
16458 }
16459
16460
16461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16462   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16463
16464   arg1 = (Dali::Property::Map *)jarg1;
16465   {
16466     try {
16467       (arg1)->Clear();
16468     } catch (std::out_of_range& e) {
16469       {
16470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16471       };
16472     } catch (std::exception& e) {
16473       {
16474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16475       };
16476     } catch (Dali::DaliException e) {
16477       {
16478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16479       };
16480     } catch (...) {
16481       {
16482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16483       };
16484     }
16485   }
16486
16487 }
16488
16489
16490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16491   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16492   Dali::Property::Map *arg2 = 0 ;
16493
16494   arg1 = (Dali::Property::Map *)jarg1;
16495   arg2 = (Dali::Property::Map *)jarg2;
16496   if (!arg2) {
16497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16498     return ;
16499   }
16500   {
16501     try {
16502       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16503     } catch (std::out_of_range& e) {
16504       {
16505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16506       };
16507     } catch (std::exception& e) {
16508       {
16509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16510       };
16511     } catch (Dali::DaliException e) {
16512       {
16513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16514       };
16515     } catch (...) {
16516       {
16517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16518       };
16519     }
16520   }
16521
16522 }
16523
16524
16525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16526   void * jresult ;
16527   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16528   std::string *arg2 = 0 ;
16529   Dali::Property::Value *result = 0 ;
16530
16531   arg1 = (Dali::Property::Map *)jarg1;
16532   if (!jarg2) {
16533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16534     return 0;
16535   }
16536   std::string arg2_str(jarg2);
16537   arg2 = &arg2_str;
16538   {
16539     try {
16540       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16541     } catch (std::out_of_range& e) {
16542       {
16543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16544       };
16545     } catch (std::exception& e) {
16546       {
16547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16548       };
16549     } catch (Dali::DaliException e) {
16550       {
16551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16552       };
16553     } catch (...) {
16554       {
16555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16556       };
16557     }
16558   }
16559
16560   jresult = (void *)result;
16561
16562   //argout typemap for const std::string&
16563
16564   return jresult;
16565 }
16566
16567
16568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16569   void * jresult ;
16570   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16571   Dali::Property::Index arg2 ;
16572   Dali::Property::Value *result = 0 ;
16573
16574   arg1 = (Dali::Property::Map *)jarg1;
16575   arg2 = (Dali::Property::Index)jarg2;
16576   {
16577     try {
16578       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16579     } catch (std::out_of_range& e) {
16580       {
16581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16582       };
16583     } catch (std::exception& e) {
16584       {
16585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16586       };
16587     } catch (Dali::DaliException e) {
16588       {
16589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16590       };
16591     } catch (...) {
16592       {
16593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16594       };
16595     }
16596   }
16597
16598   jresult = (void *)result;
16599   return jresult;
16600 }
16601
16602
16603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16604   void * jresult ;
16605   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16606   Dali::Property::Map *arg2 = 0 ;
16607   Dali::Property::Map *result = 0 ;
16608
16609   arg1 = (Dali::Property::Map *)jarg1;
16610   arg2 = (Dali::Property::Map *)jarg2;
16611   if (!arg2) {
16612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16613     return 0;
16614   }
16615   {
16616     try {
16617       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16618     } catch (std::out_of_range& e) {
16619       {
16620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16621       };
16622     } catch (std::exception& e) {
16623       {
16624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16625       };
16626     } catch (Dali::DaliException e) {
16627       {
16628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16629       };
16630     } catch (...) {
16631       {
16632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16633       };
16634     }
16635   }
16636
16637   jresult = (void *)result;
16638   return jresult;
16639 }
16640
16641
16642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16643   void * jresult ;
16644   Dali::Property::Value *result = 0 ;
16645
16646   {
16647     try {
16648       result = (Dali::Property::Value *)new Dali::Property::Value();
16649     } catch (std::out_of_range& e) {
16650       {
16651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16652       };
16653     } catch (std::exception& e) {
16654       {
16655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16656       };
16657     } catch (Dali::DaliException e) {
16658       {
16659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16660       };
16661     } catch (...) {
16662       {
16663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16664       };
16665     }
16666   }
16667
16668   jresult = (void *)result;
16669   return jresult;
16670 }
16671
16672
16673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16674   void * jresult ;
16675   bool arg1 ;
16676   Dali::Property::Value *result = 0 ;
16677
16678   arg1 = jarg1 ? true : false;
16679   {
16680     try {
16681       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16682     } catch (std::out_of_range& e) {
16683       {
16684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16685       };
16686     } catch (std::exception& e) {
16687       {
16688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16689       };
16690     } catch (Dali::DaliException e) {
16691       {
16692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16693       };
16694     } catch (...) {
16695       {
16696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16697       };
16698     }
16699   }
16700
16701   jresult = (void *)result;
16702   return jresult;
16703 }
16704
16705
16706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16707   void * jresult ;
16708   int arg1 ;
16709   Dali::Property::Value *result = 0 ;
16710
16711   arg1 = (int)jarg1;
16712   {
16713     try {
16714       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16715     } catch (std::out_of_range& e) {
16716       {
16717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16718       };
16719     } catch (std::exception& e) {
16720       {
16721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16722       };
16723     } catch (Dali::DaliException e) {
16724       {
16725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16726       };
16727     } catch (...) {
16728       {
16729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16730       };
16731     }
16732   }
16733
16734   jresult = (void *)result;
16735   return jresult;
16736 }
16737
16738
16739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16740   void * jresult ;
16741   float arg1 ;
16742   Dali::Property::Value *result = 0 ;
16743
16744   arg1 = (float)jarg1;
16745   {
16746     try {
16747       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16748     } catch (std::out_of_range& e) {
16749       {
16750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16751       };
16752     } catch (std::exception& e) {
16753       {
16754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16755       };
16756     } catch (Dali::DaliException e) {
16757       {
16758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16759       };
16760     } catch (...) {
16761       {
16762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16763       };
16764     }
16765   }
16766
16767   jresult = (void *)result;
16768   return jresult;
16769 }
16770
16771
16772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16773   void * jresult ;
16774   Dali::Vector2 *arg1 = 0 ;
16775   Dali::Property::Value *result = 0 ;
16776
16777   arg1 = (Dali::Vector2 *)jarg1;
16778   if (!arg1) {
16779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16780     return 0;
16781   }
16782   {
16783     try {
16784       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16785     } catch (std::out_of_range& e) {
16786       {
16787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16788       };
16789     } catch (std::exception& e) {
16790       {
16791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16792       };
16793     } catch (Dali::DaliException e) {
16794       {
16795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16796       };
16797     } catch (...) {
16798       {
16799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16800       };
16801     }
16802   }
16803
16804   jresult = (void *)result;
16805   return jresult;
16806 }
16807
16808
16809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16810   void * jresult ;
16811   Dali::Vector3 *arg1 = 0 ;
16812   Dali::Property::Value *result = 0 ;
16813
16814   arg1 = (Dali::Vector3 *)jarg1;
16815   if (!arg1) {
16816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16817     return 0;
16818   }
16819   {
16820     try {
16821       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16822     } catch (std::out_of_range& e) {
16823       {
16824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16825       };
16826     } catch (std::exception& e) {
16827       {
16828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16829       };
16830     } catch (Dali::DaliException e) {
16831       {
16832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16833       };
16834     } catch (...) {
16835       {
16836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16837       };
16838     }
16839   }
16840
16841   jresult = (void *)result;
16842   return jresult;
16843 }
16844
16845
16846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16847   void * jresult ;
16848   Dali::Vector4 *arg1 = 0 ;
16849   Dali::Property::Value *result = 0 ;
16850
16851   arg1 = (Dali::Vector4 *)jarg1;
16852   if (!arg1) {
16853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16854     return 0;
16855   }
16856   {
16857     try {
16858       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16859     } catch (std::out_of_range& e) {
16860       {
16861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16862       };
16863     } catch (std::exception& e) {
16864       {
16865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16866       };
16867     } catch (Dali::DaliException e) {
16868       {
16869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16870       };
16871     } catch (...) {
16872       {
16873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16874       };
16875     }
16876   }
16877
16878   jresult = (void *)result;
16879   return jresult;
16880 }
16881
16882
16883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16884   void * jresult ;
16885   Dali::Matrix3 *arg1 = 0 ;
16886   Dali::Property::Value *result = 0 ;
16887
16888   arg1 = (Dali::Matrix3 *)jarg1;
16889   if (!arg1) {
16890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16891     return 0;
16892   }
16893   {
16894     try {
16895       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16896     } catch (std::out_of_range& e) {
16897       {
16898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16899       };
16900     } catch (std::exception& e) {
16901       {
16902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16903       };
16904     } catch (Dali::DaliException e) {
16905       {
16906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16907       };
16908     } catch (...) {
16909       {
16910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16911       };
16912     }
16913   }
16914
16915   jresult = (void *)result;
16916   return jresult;
16917 }
16918
16919
16920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16921   void * jresult ;
16922   Dali::Matrix *arg1 = 0 ;
16923   Dali::Property::Value *result = 0 ;
16924
16925   arg1 = (Dali::Matrix *)jarg1;
16926   if (!arg1) {
16927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16928     return 0;
16929   }
16930   {
16931     try {
16932       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16933     } catch (std::out_of_range& e) {
16934       {
16935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16936       };
16937     } catch (std::exception& e) {
16938       {
16939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16940       };
16941     } catch (Dali::DaliException e) {
16942       {
16943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16944       };
16945     } catch (...) {
16946       {
16947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16948       };
16949     }
16950   }
16951
16952   jresult = (void *)result;
16953   return jresult;
16954 }
16955
16956
16957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16958   void * jresult ;
16959   Dali::Rect< int > *arg1 = 0 ;
16960   Dali::Property::Value *result = 0 ;
16961
16962   arg1 = (Dali::Rect< int > *)jarg1;
16963   if (!arg1) {
16964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16965     return 0;
16966   }
16967   {
16968     try {
16969       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16970     } catch (std::out_of_range& e) {
16971       {
16972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16973       };
16974     } catch (std::exception& e) {
16975       {
16976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16977       };
16978     } catch (Dali::DaliException e) {
16979       {
16980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16981       };
16982     } catch (...) {
16983       {
16984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16985       };
16986     }
16987   }
16988
16989   jresult = (void *)result;
16990   return jresult;
16991 }
16992
16993
16994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16995   void * jresult ;
16996   Dali::AngleAxis *arg1 = 0 ;
16997   Dali::Property::Value *result = 0 ;
16998
16999   arg1 = (Dali::AngleAxis *)jarg1;
17000   if (!arg1) {
17001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17002     return 0;
17003   }
17004   {
17005     try {
17006       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17007     } catch (std::out_of_range& e) {
17008       {
17009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17010       };
17011     } catch (std::exception& e) {
17012       {
17013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17014       };
17015     } catch (Dali::DaliException e) {
17016       {
17017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17018       };
17019     } catch (...) {
17020       {
17021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17022       };
17023     }
17024   }
17025
17026   jresult = (void *)result;
17027   return jresult;
17028 }
17029
17030
17031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17032   void * jresult ;
17033   Dali::Quaternion *arg1 = 0 ;
17034   Dali::Property::Value *result = 0 ;
17035
17036   arg1 = (Dali::Quaternion *)jarg1;
17037   if (!arg1) {
17038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17039     return 0;
17040   }
17041   {
17042     try {
17043       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17044     } catch (std::out_of_range& e) {
17045       {
17046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17047       };
17048     } catch (std::exception& e) {
17049       {
17050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17051       };
17052     } catch (Dali::DaliException e) {
17053       {
17054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17055       };
17056     } catch (...) {
17057       {
17058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17059       };
17060     }
17061   }
17062
17063   jresult = (void *)result;
17064   return jresult;
17065 }
17066
17067
17068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17069   void * jresult ;
17070   std::string *arg1 = 0 ;
17071   Dali::Property::Value *result = 0 ;
17072
17073   if (!jarg1) {
17074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17075     return 0;
17076   }
17077   std::string arg1_str(jarg1);
17078   arg1 = &arg1_str;
17079   {
17080     try {
17081       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17082     } catch (std::out_of_range& e) {
17083       {
17084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17085       };
17086     } catch (std::exception& e) {
17087       {
17088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17089       };
17090     } catch (Dali::DaliException e) {
17091       {
17092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17093       };
17094     } catch (...) {
17095       {
17096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17097       };
17098     }
17099   }
17100
17101   jresult = (void *)result;
17102
17103   //argout typemap for const std::string&
17104
17105   return jresult;
17106 }
17107
17108
17109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17110   void * jresult ;
17111   Dali::Property::Array *arg1 = 0 ;
17112   Dali::Property::Value *result = 0 ;
17113
17114   arg1 = (Dali::Property::Array *)jarg1;
17115   if (!arg1) {
17116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17117     return 0;
17118   }
17119   {
17120     try {
17121       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17122     } catch (std::out_of_range& e) {
17123       {
17124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17125       };
17126     } catch (std::exception& e) {
17127       {
17128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17129       };
17130     } catch (Dali::DaliException e) {
17131       {
17132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17133       };
17134     } catch (...) {
17135       {
17136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17137       };
17138     }
17139   }
17140
17141   jresult = (void *)result;
17142   return jresult;
17143 }
17144
17145
17146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17147   void * jresult ;
17148   Dali::Property::Map *arg1 = 0 ;
17149   Dali::Property::Value *result = 0 ;
17150
17151   arg1 = (Dali::Property::Map *)jarg1;
17152   if (!arg1) {
17153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17154     return 0;
17155   }
17156   {
17157     try {
17158       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17159     } catch (std::out_of_range& e) {
17160       {
17161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17162       };
17163     } catch (std::exception& e) {
17164       {
17165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17166       };
17167     } catch (Dali::DaliException e) {
17168       {
17169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17170       };
17171     } catch (...) {
17172       {
17173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17174       };
17175     }
17176   }
17177
17178   jresult = (void *)result;
17179   return jresult;
17180 }
17181
17182
17183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17184   void * jresult ;
17185   Extents *arg1 = 0 ;
17186   Dali::Property::Value *result = 0 ;
17187
17188   arg1 = (Extents *)jarg1;
17189   if (!arg1) {
17190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17191     return 0;
17192   }
17193   {
17194     try {
17195       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17196     } catch (std::out_of_range& e) {
17197       {
17198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17199       };
17200     } catch (std::exception& e) {
17201       {
17202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17203       };
17204     } catch (...) {
17205       {
17206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17207       };
17208     }
17209   }
17210   jresult = (void *)result;
17211   return jresult;
17212 }
17213
17214
17215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17216   void * jresult ;
17217   Dali::Property::Type arg1 ;
17218   Dali::Property::Value *result = 0 ;
17219
17220   arg1 = (Dali::Property::Type)jarg1;
17221   {
17222     try {
17223       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17224     } catch (std::out_of_range& e) {
17225       {
17226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17227       };
17228     } catch (std::exception& e) {
17229       {
17230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17231       };
17232     } catch (Dali::DaliException e) {
17233       {
17234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17235       };
17236     } catch (...) {
17237       {
17238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17239       };
17240     }
17241   }
17242
17243   jresult = (void *)result;
17244   return jresult;
17245 }
17246
17247
17248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17249   void * jresult ;
17250   Dali::Property::Value *arg1 = 0 ;
17251   Dali::Property::Value *result = 0 ;
17252
17253   arg1 = (Dali::Property::Value *)jarg1;
17254   if (!arg1) {
17255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17256     return 0;
17257   }
17258   {
17259     try {
17260       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17261     } catch (std::out_of_range& e) {
17262       {
17263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17264       };
17265     } catch (std::exception& e) {
17266       {
17267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17268       };
17269     } catch (Dali::DaliException e) {
17270       {
17271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17272       };
17273     } catch (...) {
17274       {
17275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17276       };
17277     }
17278   }
17279
17280   jresult = (void *)result;
17281   return jresult;
17282 }
17283
17284
17285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17286   void * jresult ;
17287   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17288   Dali::Property::Value *arg2 = 0 ;
17289   Dali::Property::Value *result = 0 ;
17290
17291   arg1 = (Dali::Property::Value *)jarg1;
17292   arg2 = (Dali::Property::Value *)jarg2;
17293   if (!arg2) {
17294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17295     return 0;
17296   }
17297   {
17298     try {
17299       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17300     } catch (std::out_of_range& e) {
17301       {
17302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17303       };
17304     } catch (std::exception& e) {
17305       {
17306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17307       };
17308     } catch (Dali::DaliException e) {
17309       {
17310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17311       };
17312     } catch (...) {
17313       {
17314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17315       };
17316     }
17317   }
17318
17319   jresult = (void *)result;
17320   return jresult;
17321 }
17322
17323
17324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17325   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17326
17327   arg1 = (Dali::Property::Value *)jarg1;
17328   {
17329     try {
17330       delete arg1;
17331     } catch (std::out_of_range& e) {
17332       {
17333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17334       };
17335     } catch (std::exception& e) {
17336       {
17337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17338       };
17339     } catch (Dali::DaliException e) {
17340       {
17341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17342       };
17343     } catch (...) {
17344       {
17345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17346       };
17347     }
17348   }
17349
17350 }
17351
17352
17353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17354   int jresult ;
17355   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17356   Dali::Property::Type result;
17357
17358   arg1 = (Dali::Property::Value *)jarg1;
17359   {
17360     try {
17361       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17362     } catch (std::out_of_range& e) {
17363       {
17364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17365       };
17366     } catch (std::exception& e) {
17367       {
17368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17369       };
17370     } catch (Dali::DaliException e) {
17371       {
17372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17373       };
17374     } catch (...) {
17375       {
17376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17377       };
17378     }
17379   }
17380
17381   jresult = (int)result;
17382   return jresult;
17383 }
17384
17385
17386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17387   unsigned int jresult ;
17388   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17389   bool *arg2 = 0 ;
17390   bool result;
17391
17392   arg1 = (Dali::Property::Value *)jarg1;
17393   arg2 = (bool *)jarg2;
17394   {
17395     try {
17396       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17397     } catch (std::out_of_range& e) {
17398       {
17399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17400       };
17401     } catch (std::exception& e) {
17402       {
17403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17404       };
17405     } catch (Dali::DaliException e) {
17406       {
17407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17408       };
17409     } catch (...) {
17410       {
17411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17412       };
17413     }
17414   }
17415
17416   jresult = result;
17417   return jresult;
17418 }
17419
17420
17421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17422   unsigned int jresult ;
17423   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17424   float *arg2 = 0 ;
17425   bool result;
17426
17427   arg1 = (Dali::Property::Value *)jarg1;
17428   arg2 = (float *)jarg2;
17429   {
17430     try {
17431       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17432     } catch (std::out_of_range& e) {
17433       {
17434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17435       };
17436     } catch (std::exception& e) {
17437       {
17438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17439       };
17440     } catch (Dali::DaliException e) {
17441       {
17442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17443       };
17444     } catch (...) {
17445       {
17446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17447       };
17448     }
17449   }
17450
17451   jresult = result;
17452   return jresult;
17453 }
17454
17455
17456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17457   unsigned int jresult ;
17458   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17459   int *arg2 = 0 ;
17460   bool result;
17461
17462   arg1 = (Dali::Property::Value *)jarg1;
17463   arg2 = (int *)jarg2;
17464   {
17465     try {
17466       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17467     } catch (std::out_of_range& e) {
17468       {
17469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17470       };
17471     } catch (std::exception& e) {
17472       {
17473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17474       };
17475     } catch (Dali::DaliException e) {
17476       {
17477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17478       };
17479     } catch (...) {
17480       {
17481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17482       };
17483     }
17484   }
17485
17486   jresult = result;
17487   return jresult;
17488 }
17489
17490
17491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17492   unsigned int jresult ;
17493   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17494   Dali::Rect< int > *arg2 = 0 ;
17495   bool result;
17496
17497   arg1 = (Dali::Property::Value *)jarg1;
17498   arg2 = (Dali::Rect< int > *)jarg2;
17499   if (!arg2) {
17500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17501     return 0;
17502   }
17503   {
17504     try {
17505       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17506     } catch (std::out_of_range& e) {
17507       {
17508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17509       };
17510     } catch (std::exception& e) {
17511       {
17512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17513       };
17514     } catch (Dali::DaliException e) {
17515       {
17516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17517       };
17518     } catch (...) {
17519       {
17520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17521       };
17522     }
17523   }
17524
17525   jresult = result;
17526   return jresult;
17527 }
17528
17529
17530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17531   unsigned int jresult ;
17532   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17533   Dali::Vector2 *arg2 = 0 ;
17534   bool result;
17535
17536   arg1 = (Dali::Property::Value *)jarg1;
17537   arg2 = (Dali::Vector2 *)jarg2;
17538   if (!arg2) {
17539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17540     return 0;
17541   }
17542   {
17543     try {
17544       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17545     } catch (std::out_of_range& e) {
17546       {
17547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17548       };
17549     } catch (std::exception& e) {
17550       {
17551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17552       };
17553     } catch (Dali::DaliException e) {
17554       {
17555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17556       };
17557     } catch (...) {
17558       {
17559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17560       };
17561     }
17562   }
17563
17564   jresult = result;
17565   return jresult;
17566 }
17567
17568
17569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17570   unsigned int jresult ;
17571   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17572   Dali::Vector3 *arg2 = 0 ;
17573   bool result;
17574
17575   arg1 = (Dali::Property::Value *)jarg1;
17576   arg2 = (Dali::Vector3 *)jarg2;
17577   if (!arg2) {
17578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17579     return 0;
17580   }
17581   {
17582     try {
17583       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17584     } catch (std::out_of_range& e) {
17585       {
17586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17587       };
17588     } catch (std::exception& e) {
17589       {
17590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17591       };
17592     } catch (Dali::DaliException e) {
17593       {
17594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17595       };
17596     } catch (...) {
17597       {
17598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17599       };
17600     }
17601   }
17602
17603   jresult = result;
17604   return jresult;
17605 }
17606
17607
17608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17609   unsigned int jresult ;
17610   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17611   Dali::Vector4 *arg2 = 0 ;
17612   bool result;
17613
17614   arg1 = (Dali::Property::Value *)jarg1;
17615   arg2 = (Dali::Vector4 *)jarg2;
17616   if (!arg2) {
17617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17618     return 0;
17619   }
17620   {
17621     try {
17622       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17623     } catch (std::out_of_range& e) {
17624       {
17625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17626       };
17627     } catch (std::exception& e) {
17628       {
17629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17630       };
17631     } catch (Dali::DaliException e) {
17632       {
17633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17634       };
17635     } catch (...) {
17636       {
17637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17638       };
17639     }
17640   }
17641
17642   jresult = result;
17643   return jresult;
17644 }
17645
17646
17647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17648   unsigned int jresult ;
17649   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17650   Dali::Matrix3 *arg2 = 0 ;
17651   bool result;
17652
17653   arg1 = (Dali::Property::Value *)jarg1;
17654   arg2 = (Dali::Matrix3 *)jarg2;
17655   if (!arg2) {
17656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17657     return 0;
17658   }
17659   {
17660     try {
17661       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17662     } catch (std::out_of_range& e) {
17663       {
17664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17665       };
17666     } catch (std::exception& e) {
17667       {
17668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17669       };
17670     } catch (Dali::DaliException e) {
17671       {
17672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17673       };
17674     } catch (...) {
17675       {
17676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17677       };
17678     }
17679   }
17680
17681   jresult = result;
17682   return jresult;
17683 }
17684
17685
17686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17687   unsigned int jresult ;
17688   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17689   Dali::Matrix *arg2 = 0 ;
17690   bool result;
17691
17692   arg1 = (Dali::Property::Value *)jarg1;
17693   arg2 = (Dali::Matrix *)jarg2;
17694   if (!arg2) {
17695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17696     return 0;
17697   }
17698   {
17699     try {
17700       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17701     } catch (std::out_of_range& e) {
17702       {
17703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17704       };
17705     } catch (std::exception& e) {
17706       {
17707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17708       };
17709     } catch (Dali::DaliException e) {
17710       {
17711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17712       };
17713     } catch (...) {
17714       {
17715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17716       };
17717     }
17718   }
17719
17720   jresult = result;
17721   return jresult;
17722 }
17723
17724
17725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17726   unsigned int jresult ;
17727   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17728   Dali::AngleAxis *arg2 = 0 ;
17729   bool result;
17730
17731   arg1 = (Dali::Property::Value *)jarg1;
17732   arg2 = (Dali::AngleAxis *)jarg2;
17733   if (!arg2) {
17734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17735     return 0;
17736   }
17737   {
17738     try {
17739       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17740     } catch (std::out_of_range& e) {
17741       {
17742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17743       };
17744     } catch (std::exception& e) {
17745       {
17746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17747       };
17748     } catch (Dali::DaliException e) {
17749       {
17750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17751       };
17752     } catch (...) {
17753       {
17754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17755       };
17756     }
17757   }
17758
17759   jresult = result;
17760   return jresult;
17761 }
17762
17763
17764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17765   unsigned int jresult ;
17766   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17767   Dali::Quaternion *arg2 = 0 ;
17768   bool result;
17769
17770   arg1 = (Dali::Property::Value *)jarg1;
17771   arg2 = (Dali::Quaternion *)jarg2;
17772   if (!arg2) {
17773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17774     return 0;
17775   }
17776   {
17777     try {
17778       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17779     } catch (std::out_of_range& e) {
17780       {
17781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17782       };
17783     } catch (std::exception& e) {
17784       {
17785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17786       };
17787     } catch (Dali::DaliException e) {
17788       {
17789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17790       };
17791     } catch (...) {
17792       {
17793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17794       };
17795     }
17796   }
17797
17798   jresult = result;
17799   return jresult;
17800 }
17801
17802
17803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17804   unsigned int jresult ;
17805   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17806   std::string *arg2 = 0 ;
17807   bool result;
17808
17809   arg1 = (Dali::Property::Value *)jarg1;
17810
17811   //typemap in
17812   std::string temp;
17813   arg2 = &temp;
17814
17815   {
17816     try {
17817       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17818     } catch (std::out_of_range& e) {
17819       {
17820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17821       };
17822     } catch (std::exception& e) {
17823       {
17824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17825       };
17826     } catch (Dali::DaliException e) {
17827       {
17828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17829       };
17830     } catch (...) {
17831       {
17832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17833       };
17834     }
17835   }
17836
17837   jresult = result;
17838
17839   //Typemap argout in c++ file.
17840   //This will convert c++ string to c# string
17841   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17842
17843   return jresult;
17844 }
17845
17846
17847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17848   unsigned int jresult ;
17849   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17850   Dali::Property::Array *arg2 = 0 ;
17851   bool result;
17852
17853   arg1 = (Dali::Property::Value *)jarg1;
17854   arg2 = (Dali::Property::Array *)jarg2;
17855   if (!arg2) {
17856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17857     return 0;
17858   }
17859   {
17860     try {
17861       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17862     } catch (std::out_of_range& e) {
17863       {
17864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17865       };
17866     } catch (std::exception& e) {
17867       {
17868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17869       };
17870     } catch (Dali::DaliException e) {
17871       {
17872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17873       };
17874     } catch (...) {
17875       {
17876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17877       };
17878     }
17879   }
17880
17881   jresult = result;
17882   return jresult;
17883 }
17884
17885
17886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17887   unsigned int jresult ;
17888   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17889   Dali::Property::Map *arg2 = 0 ;
17890   bool result;
17891
17892   arg1 = (Dali::Property::Value *)jarg1;
17893   arg2 = (Dali::Property::Map *)jarg2;
17894   if (!arg2) {
17895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17896     return 0;
17897   }
17898   {
17899     try {
17900       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17901     } catch (std::out_of_range& e) {
17902       {
17903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17904       };
17905     } catch (std::exception& e) {
17906       {
17907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17908       };
17909     } catch (Dali::DaliException e) {
17910       {
17911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17912       };
17913     } catch (...) {
17914       {
17915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17916       };
17917     }
17918   }
17919
17920   jresult = result;
17921   return jresult;
17922 }
17923
17924
17925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17926   unsigned int jresult ;
17927   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17928   Extents *arg2 = 0 ;
17929   bool result;
17930
17931   arg1 = (Dali::Property::Value *)jarg1;
17932   arg2 = (Extents *)jarg2;
17933   if (!arg2) {
17934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17935     return 0;
17936   }
17937   {
17938     try {
17939       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17940     } catch (std::out_of_range& e) {
17941       {
17942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17943       };
17944     } catch (std::exception& e) {
17945       {
17946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17947       };
17948     } catch (...) {
17949       {
17950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17951       };
17952     }
17953   }
17954   jresult = result;
17955   return jresult;
17956 }
17957
17958
17959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17960   void * jresult ;
17961   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17962   Dali::Property::Array *result = 0 ;
17963
17964   arg1 = (Dali::Property::Value *)jarg1;
17965   {
17966     try {
17967       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17968     } catch (std::out_of_range& e) {
17969       {
17970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17971       };
17972     } catch (std::exception& e) {
17973       {
17974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17975       };
17976     } catch (Dali::DaliException e) {
17977       {
17978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17979       };
17980     } catch (...) {
17981       {
17982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17983       };
17984     }
17985   }
17986
17987   jresult = (void *)result;
17988   return jresult;
17989 }
17990
17991
17992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17993   void * jresult ;
17994   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17995   Dali::Property::Map *result = 0 ;
17996
17997   arg1 = (Dali::Property::Value *)jarg1;
17998   {
17999     try {
18000       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18001     } catch (std::out_of_range& e) {
18002       {
18003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18004       };
18005     } catch (std::exception& e) {
18006       {
18007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18008       };
18009     } catch (Dali::DaliException e) {
18010       {
18011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18012       };
18013     } catch (...) {
18014       {
18015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18016       };
18017     }
18018   }
18019
18020   jresult = (void *)result;
18021   return jresult;
18022 }
18023
18024
18025 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18026   char * jresult ;
18027   Dali::Property::Type arg1 ;
18028   char *result = 0 ;
18029
18030   arg1 = (Dali::Property::Type)jarg1;
18031   {
18032     try {
18033       result = (char *)Dali::PropertyTypes::GetName(arg1);
18034     } catch (std::out_of_range& e) {
18035       {
18036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18037       };
18038     } catch (std::exception& e) {
18039       {
18040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18041       };
18042     } catch (Dali::DaliException e) {
18043       {
18044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18045       };
18046     } catch (...) {
18047       {
18048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18049       };
18050     }
18051   }
18052
18053   jresult = SWIG_csharp_string_callback((const char *)result);
18054   return jresult;
18055 }
18056
18057
18058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18059   unsigned int jresult ;
18060   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18061   std::string *arg2 = 0 ;
18062   Dali::Property::Map *arg3 = 0 ;
18063   bool result;
18064
18065   arg1 = (Dali::BaseObject *)jarg1;
18066   if (!jarg2) {
18067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18068     return 0;
18069   }
18070   std::string arg2_str(jarg2);
18071   arg2 = &arg2_str;
18072   arg3 = (Dali::Property::Map *)jarg3;
18073   if (!arg3) {
18074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18075     return 0;
18076   }
18077   {
18078     try {
18079       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18080     } catch (std::out_of_range& e) {
18081       {
18082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18083       };
18084     } catch (std::exception& e) {
18085       {
18086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18087       };
18088     } catch (Dali::DaliException e) {
18089       {
18090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18091       };
18092     } catch (...) {
18093       {
18094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18095       };
18096     }
18097   }
18098
18099   jresult = result;
18100
18101   //argout typemap for const std::string&
18102
18103   return jresult;
18104 }
18105
18106
18107 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18108   char * jresult ;
18109   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18110   std::string *result = 0 ;
18111
18112   arg1 = (Dali::BaseObject *)jarg1;
18113   {
18114     try {
18115       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18116     } catch (std::out_of_range& e) {
18117       {
18118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18119       };
18120     } catch (std::exception& e) {
18121       {
18122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18123       };
18124     } catch (Dali::DaliException e) {
18125       {
18126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18127       };
18128     } catch (...) {
18129       {
18130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18131       };
18132     }
18133   }
18134
18135   jresult = SWIG_csharp_string_callback(result->c_str());
18136   return jresult;
18137 }
18138
18139
18140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18141   unsigned int jresult ;
18142   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18143   Dali::TypeInfo *arg2 = 0 ;
18144   bool result;
18145
18146   arg1 = (Dali::BaseObject *)jarg1;
18147   arg2 = (Dali::TypeInfo *)jarg2;
18148   if (!arg2) {
18149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18150     return 0;
18151   }
18152   {
18153     try {
18154       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18155     } catch (std::out_of_range& e) {
18156       {
18157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18158       };
18159     } catch (std::exception& e) {
18160       {
18161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18162       };
18163     } catch (Dali::DaliException e) {
18164       {
18165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18166       };
18167     } catch (...) {
18168       {
18169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18170       };
18171     }
18172   }
18173
18174   jresult = result;
18175   return jresult;
18176 }
18177
18178
18179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18180   unsigned int jresult ;
18181   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18182   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18183   std::string *arg3 = 0 ;
18184   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18185   bool result;
18186
18187   arg1 = (Dali::BaseObject *)jarg1;
18188   arg2 = (ConnectionTrackerInterface *)jarg2;
18189   if (!jarg3) {
18190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18191     return 0;
18192   }
18193   std::string arg3_str(jarg3);
18194   arg3 = &arg3_str;
18195   arg4 = (FunctorDelegate *)jarg4;
18196   {
18197     try {
18198       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18199     } catch (std::out_of_range& e) {
18200       {
18201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18202       };
18203     } catch (std::exception& e) {
18204       {
18205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18206       };
18207     } catch (Dali::DaliException e) {
18208       {
18209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18210       };
18211     } catch (...) {
18212       {
18213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18214       };
18215     }
18216   }
18217
18218   jresult = result;
18219
18220   //argout typemap for const std::string&
18221
18222   return jresult;
18223 }
18224
18225
18226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18227   void * jresult ;
18228   Dali::BaseHandle *arg1 = 0 ;
18229   Dali::BaseObject *result = 0 ;
18230
18231   arg1 = (Dali::BaseHandle *)jarg1;
18232   if (!arg1) {
18233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18234     return 0;
18235   }
18236   {
18237     try {
18238       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18239     } catch (std::out_of_range& e) {
18240       {
18241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18242       };
18243     } catch (std::exception& e) {
18244       {
18245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18246       };
18247     } catch (Dali::DaliException e) {
18248       {
18249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18250       };
18251     } catch (...) {
18252       {
18253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18254       };
18255     }
18256   }
18257
18258   jresult = (void *)result;
18259   return jresult;
18260 }
18261
18262
18263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18264   void * jresult ;
18265   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18266   Dali::BaseHandle *result = 0 ;
18267
18268   arg1 = (Dali::BaseObject *)jarg1;
18269   {
18270     try {
18271       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18272     } catch (std::out_of_range& e) {
18273       {
18274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18275       };
18276     } catch (std::exception& e) {
18277       {
18278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18279       };
18280     } catch (Dali::DaliException e) {
18281       {
18282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18283       };
18284     } catch (...) {
18285       {
18286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18287       };
18288     }
18289   }
18290
18291   jresult = (void *)result;
18292   return jresult;
18293 }
18294
18295
18296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18297   void * jresult ;
18298   Dali::BaseHandle *result = 0 ;
18299
18300   {
18301     try {
18302       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18303     } catch (std::out_of_range& e) {
18304       {
18305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18306       };
18307     } catch (std::exception& e) {
18308       {
18309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18310       };
18311     } catch (Dali::DaliException e) {
18312       {
18313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18314       };
18315     } catch (...) {
18316       {
18317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18318       };
18319     }
18320   }
18321
18322   jresult = (void *)result;
18323   return jresult;
18324 }
18325
18326
18327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18328   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18329
18330   arg1 = (Dali::BaseHandle *)jarg1;
18331   {
18332     try {
18333       delete arg1;
18334     } catch (std::out_of_range& e) {
18335       {
18336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18337       };
18338     } catch (std::exception& e) {
18339       {
18340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18341       };
18342     } catch (Dali::DaliException e) {
18343       {
18344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18345       };
18346     } catch (...) {
18347       {
18348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18349       };
18350     }
18351   }
18352
18353 }
18354
18355
18356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18357   void * jresult ;
18358   Dali::BaseHandle *arg1 = 0 ;
18359   Dali::BaseHandle *result = 0 ;
18360
18361   arg1 = (Dali::BaseHandle *)jarg1;
18362   if (!arg1) {
18363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18364     return 0;
18365   }
18366   {
18367     try {
18368       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18369     } catch (std::out_of_range& e) {
18370       {
18371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18372       };
18373     } catch (std::exception& e) {
18374       {
18375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18376       };
18377     } catch (Dali::DaliException e) {
18378       {
18379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18380       };
18381     } catch (...) {
18382       {
18383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18384       };
18385     }
18386   }
18387
18388   jresult = (void *)result;
18389   return jresult;
18390 }
18391
18392
18393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18394   void * jresult ;
18395   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18396   Dali::BaseHandle *arg2 = 0 ;
18397   Dali::BaseHandle *result = 0 ;
18398
18399   arg1 = (Dali::BaseHandle *)jarg1;
18400   arg2 = (Dali::BaseHandle *)jarg2;
18401   if (!arg2) {
18402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18403     return 0;
18404   }
18405   {
18406     try {
18407       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18408     } catch (std::out_of_range& e) {
18409       {
18410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18411       };
18412     } catch (std::exception& e) {
18413       {
18414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18415       };
18416     } catch (Dali::DaliException e) {
18417       {
18418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18419       };
18420     } catch (...) {
18421       {
18422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18423       };
18424     }
18425   }
18426
18427   jresult = (void *)result;
18428   return jresult;
18429 }
18430
18431
18432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18433   unsigned int jresult ;
18434   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18435   std::string *arg2 = 0 ;
18436   Dali::Property::Map *arg3 = 0 ;
18437   bool result;
18438
18439   arg1 = (Dali::BaseHandle *)jarg1;
18440   if (!jarg2) {
18441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18442     return 0;
18443   }
18444   std::string arg2_str(jarg2);
18445   arg2 = &arg2_str;
18446   arg3 = (Dali::Property::Map *)jarg3;
18447   if (!arg3) {
18448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18449     return 0;
18450   }
18451   {
18452     try {
18453       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18454     } catch (std::out_of_range& e) {
18455       {
18456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18457       };
18458     } catch (std::exception& e) {
18459       {
18460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18461       };
18462     } catch (Dali::DaliException e) {
18463       {
18464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18465       };
18466     } catch (...) {
18467       {
18468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18469       };
18470     }
18471   }
18472
18473   jresult = result;
18474
18475   //argout typemap for const std::string&
18476
18477   return jresult;
18478 }
18479
18480
18481 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18482   char * jresult ;
18483   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18484   std::string *result = 0 ;
18485
18486   arg1 = (Dali::BaseHandle *)jarg1;
18487   {
18488     try {
18489       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18490     } catch (std::out_of_range& e) {
18491       {
18492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18493       };
18494     } catch (std::exception& e) {
18495       {
18496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18497       };
18498     } catch (Dali::DaliException e) {
18499       {
18500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18501       };
18502     } catch (...) {
18503       {
18504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18505       };
18506     }
18507   }
18508
18509   jresult = SWIG_csharp_string_callback(result->c_str());
18510   return jresult;
18511 }
18512
18513
18514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18515   unsigned int jresult ;
18516   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18517   Dali::TypeInfo *arg2 = 0 ;
18518   bool result;
18519
18520   arg1 = (Dali::BaseHandle *)jarg1;
18521   arg2 = (Dali::TypeInfo *)jarg2;
18522   if (!arg2) {
18523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18524     return 0;
18525   }
18526   {
18527     try {
18528       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18529     } catch (std::out_of_range& e) {
18530       {
18531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18532       };
18533     } catch (std::exception& e) {
18534       {
18535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18536       };
18537     } catch (Dali::DaliException e) {
18538       {
18539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18540       };
18541     } catch (...) {
18542       {
18543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18544       };
18545     }
18546   }
18547
18548   jresult = result;
18549   return jresult;
18550 }
18551
18552
18553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18554   void * jresult ;
18555   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18556   Dali::BaseObject *result = 0 ;
18557
18558   arg1 = (Dali::BaseHandle *)jarg1;
18559   {
18560     try {
18561       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18562     } catch (std::out_of_range& e) {
18563       {
18564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18565       };
18566     } catch (std::exception& e) {
18567       {
18568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18569       };
18570     } catch (Dali::DaliException e) {
18571       {
18572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18573       };
18574     } catch (...) {
18575       {
18576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18577       };
18578     }
18579   }
18580
18581   jresult = (void *)result;
18582   return jresult;
18583 }
18584
18585
18586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18587   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18588
18589   arg1 = (Dali::BaseHandle *)jarg1;
18590   {
18591     try {
18592       (arg1)->Reset();
18593     } catch (std::out_of_range& e) {
18594       {
18595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18596       };
18597     } catch (std::exception& e) {
18598       {
18599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18600       };
18601     } catch (Dali::DaliException e) {
18602       {
18603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18604       };
18605     } catch (...) {
18606       {
18607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18608       };
18609     }
18610   }
18611
18612 }
18613
18614
18615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18616   unsigned int jresult ;
18617   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18618   Dali::BaseHandle *arg2 = 0 ;
18619   bool result;
18620
18621   arg1 = (Dali::BaseHandle *)jarg1;
18622   arg2 = (Dali::BaseHandle *)jarg2;
18623   if (!arg2) {
18624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18625     return 0;
18626   }
18627   {
18628     try {
18629       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18630     } catch (std::out_of_range& e) {
18631       {
18632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18633       };
18634     } catch (std::exception& e) {
18635       {
18636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18637       };
18638     } catch (Dali::DaliException e) {
18639       {
18640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18641       };
18642     } catch (...) {
18643       {
18644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18645       };
18646     }
18647   }
18648
18649   jresult = result;
18650   return jresult;
18651 }
18652
18653
18654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18655   unsigned int jresult ;
18656   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18657   Dali::BaseHandle *arg2 = 0 ;
18658   bool result;
18659
18660   arg1 = (Dali::BaseHandle *)jarg1;
18661   arg2 = (Dali::BaseHandle *)jarg2;
18662   if (!arg2) {
18663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18664     return 0;
18665   }
18666   {
18667     try {
18668       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18669     } catch (std::out_of_range& e) {
18670       {
18671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18672       };
18673     } catch (std::exception& e) {
18674       {
18675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18676       };
18677     } catch (Dali::DaliException e) {
18678       {
18679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18680       };
18681     } catch (...) {
18682       {
18683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18684       };
18685     }
18686   }
18687
18688   jresult = result;
18689   return jresult;
18690 }
18691
18692
18693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18694   void * jresult ;
18695   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18696   Dali::RefObject *result = 0 ;
18697
18698   arg1 = (Dali::BaseHandle *)jarg1;
18699   {
18700     try {
18701       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18702     } catch (std::out_of_range& e) {
18703       {
18704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18705       };
18706     } catch (std::exception& e) {
18707       {
18708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18709       };
18710     } catch (Dali::DaliException e) {
18711       {
18712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18713       };
18714     } catch (...) {
18715       {
18716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18717       };
18718     }
18719   }
18720
18721   jresult = (void *)result;
18722   return jresult;
18723 }
18724
18725
18726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18727   unsigned int jresult ;
18728   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18729   bool result;
18730
18731   arg1 = (Dali::BaseHandle *)jarg1;
18732   {
18733     try {
18734       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18735     } catch (std::out_of_range& e) {
18736       {
18737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18738       };
18739     } catch (std::exception& e) {
18740       {
18741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18742       };
18743     } catch (Dali::DaliException e) {
18744       {
18745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18746       };
18747     } catch (...) {
18748       {
18749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18750       };
18751     }
18752   }
18753
18754   jresult = result;
18755   return jresult;
18756 }
18757
18758
18759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18760   unsigned int jresult ;
18761   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18762   Dali::BaseHandle *arg2 = 0 ;
18763   bool result;
18764
18765   arg1 = (Dali::BaseHandle *)jarg1;
18766   arg2 = (Dali::BaseHandle *)jarg2;
18767   if (!arg2) {
18768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18769     return 0;
18770   }
18771   {
18772     try {
18773       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18774     } catch (std::out_of_range& e) {
18775       {
18776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18777       };
18778     } catch (std::exception& e) {
18779       {
18780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18781       };
18782     } catch (Dali::DaliException e) {
18783       {
18784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18785       };
18786     } catch (...) {
18787       {
18788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18789       };
18790     }
18791   }
18792
18793   jresult = result;
18794   return jresult;
18795 }
18796
18797
18798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18799   unsigned int jresult ;
18800   Dali::BaseHandle *arg1 = 0 ;
18801   Dali::BaseHandle *arg2 = 0 ;
18802   bool result;
18803
18804   arg1 = (Dali::BaseHandle *)jarg1;
18805   if (!arg1) {
18806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18807     return 0;
18808   }
18809   arg2 = (Dali::BaseHandle *)jarg2;
18810   if (!arg2) {
18811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18812     return 0;
18813   }
18814   {
18815     try {
18816       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18817     } catch (std::out_of_range& e) {
18818       {
18819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18820       };
18821     } catch (std::exception& e) {
18822       {
18823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18824       };
18825     } catch (Dali::DaliException e) {
18826       {
18827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18828       };
18829     } catch (...) {
18830       {
18831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18832       };
18833     }
18834   }
18835
18836   jresult = result;
18837   return jresult;
18838 }
18839
18840
18841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18842   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18843
18844   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18845   {
18846     try {
18847       delete arg1;
18848     } catch (std::out_of_range& e) {
18849       {
18850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18851       };
18852     } catch (std::exception& e) {
18853       {
18854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18855       };
18856     } catch (Dali::DaliException e) {
18857       {
18858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18859       };
18860     } catch (...) {
18861       {
18862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18863       };
18864     }
18865   }
18866
18867 }
18868
18869
18870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18871   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18872   SlotObserver *arg2 = (SlotObserver *) 0 ;
18873   CallbackBase *arg3 = (CallbackBase *) 0 ;
18874
18875   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18876   arg2 = (SlotObserver *)jarg2;
18877   arg3 = (CallbackBase *)jarg3;
18878   {
18879     try {
18880       (arg1)->SignalConnected(arg2,arg3);
18881     } catch (std::out_of_range& e) {
18882       {
18883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18884       };
18885     } catch (std::exception& e) {
18886       {
18887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18888       };
18889     } catch (Dali::DaliException e) {
18890       {
18891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18892       };
18893     } catch (...) {
18894       {
18895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18896       };
18897     }
18898   }
18899
18900 }
18901
18902
18903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18904   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18905
18906   arg1 = (Dali::SignalObserver *)jarg1;
18907   {
18908     try {
18909       delete arg1;
18910     } catch (std::out_of_range& e) {
18911       {
18912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18913       };
18914     } catch (std::exception& e) {
18915       {
18916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18917       };
18918     } catch (Dali::DaliException e) {
18919       {
18920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18921       };
18922     } catch (...) {
18923       {
18924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18925       };
18926     }
18927   }
18928
18929 }
18930
18931
18932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18933   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18934   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18935   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18936
18937   arg1 = (Dali::SignalObserver *)jarg1;
18938   arg2 = (Dali::SlotObserver *)jarg2;
18939   arg3 = (Dali::CallbackBase *)jarg3;
18940   {
18941     try {
18942       (arg1)->SignalDisconnected(arg2,arg3);
18943     } catch (std::out_of_range& e) {
18944       {
18945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18946       };
18947     } catch (std::exception& e) {
18948       {
18949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18950       };
18951     } catch (Dali::DaliException e) {
18952       {
18953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18954       };
18955     } catch (...) {
18956       {
18957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18958       };
18959     }
18960   }
18961
18962 }
18963
18964
18965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18966   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18967
18968   arg1 = (Dali::SlotObserver *)jarg1;
18969   {
18970     try {
18971       delete arg1;
18972     } catch (std::out_of_range& e) {
18973       {
18974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18975       };
18976     } catch (std::exception& e) {
18977       {
18978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18979       };
18980     } catch (Dali::DaliException e) {
18981       {
18982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18983       };
18984     } catch (...) {
18985       {
18986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18987       };
18988     }
18989   }
18990
18991 }
18992
18993
18994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18995   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18996   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18997
18998   arg1 = (Dali::SlotObserver *)jarg1;
18999   arg2 = (Dali::CallbackBase *)jarg2;
19000   {
19001     try {
19002       (arg1)->SlotDisconnected(arg2);
19003     } catch (std::out_of_range& e) {
19004       {
19005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19006       };
19007     } catch (std::exception& e) {
19008       {
19009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19010       };
19011     } catch (Dali::DaliException e) {
19012       {
19013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19014       };
19015     } catch (...) {
19016       {
19017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19018       };
19019     }
19020   }
19021
19022 }
19023
19024
19025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19026   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19027
19028   arg1 = (Dali::ConnectionTracker *)jarg1;
19029   {
19030     try {
19031       delete arg1;
19032     } catch (std::out_of_range& e) {
19033       {
19034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19035       };
19036     } catch (std::exception& e) {
19037       {
19038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19039       };
19040     } catch (Dali::DaliException e) {
19041       {
19042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19043       };
19044     } catch (...) {
19045       {
19046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19047       };
19048     }
19049   }
19050
19051 }
19052
19053
19054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19055   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19056
19057   arg1 = (Dali::ConnectionTracker *)jarg1;
19058   {
19059     try {
19060       (arg1)->DisconnectAll();
19061     } catch (std::out_of_range& e) {
19062       {
19063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19064       };
19065     } catch (std::exception& e) {
19066       {
19067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19068       };
19069     } catch (Dali::DaliException e) {
19070       {
19071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19072       };
19073     } catch (...) {
19074       {
19075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19076       };
19077     }
19078   }
19079
19080 }
19081
19082
19083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19084   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19085   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19086   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19087
19088   arg1 = (Dali::ConnectionTracker *)jarg1;
19089   arg2 = (Dali::SlotObserver *)jarg2;
19090   arg3 = (Dali::CallbackBase *)jarg3;
19091   {
19092     try {
19093       (arg1)->SignalConnected(arg2,arg3);
19094     } catch (std::out_of_range& e) {
19095       {
19096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19097       };
19098     } catch (std::exception& e) {
19099       {
19100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19101       };
19102     } catch (Dali::DaliException e) {
19103       {
19104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19105       };
19106     } catch (...) {
19107       {
19108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19109       };
19110     }
19111   }
19112
19113 }
19114
19115
19116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19117   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19118   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19119   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19120
19121   arg1 = (Dali::ConnectionTracker *)jarg1;
19122   arg2 = (Dali::SlotObserver *)jarg2;
19123   arg3 = (Dali::CallbackBase *)jarg3;
19124   {
19125     try {
19126       (arg1)->SignalDisconnected(arg2,arg3);
19127     } catch (std::out_of_range& e) {
19128       {
19129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19130       };
19131     } catch (std::exception& e) {
19132       {
19133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19134       };
19135     } catch (Dali::DaliException e) {
19136       {
19137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19138       };
19139     } catch (...) {
19140       {
19141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19142       };
19143     }
19144   }
19145
19146 }
19147
19148
19149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19150   unsigned long jresult ;
19151   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19152   std::size_t result;
19153
19154   arg1 = (Dali::ConnectionTracker *)jarg1;
19155   {
19156     try {
19157       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19158     } catch (std::out_of_range& e) {
19159       {
19160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19161       };
19162     } catch (std::exception& e) {
19163       {
19164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19165       };
19166     } catch (Dali::DaliException e) {
19167       {
19168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19169       };
19170     } catch (...) {
19171       {
19172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19173       };
19174     }
19175   }
19176
19177   jresult = (unsigned long)result;
19178   return jresult;
19179 }
19180
19181
19182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19183   void * jresult ;
19184   Dali::ObjectRegistry *result = 0 ;
19185
19186   {
19187     try {
19188       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19189     } catch (std::out_of_range& e) {
19190       {
19191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19192       };
19193     } catch (std::exception& e) {
19194       {
19195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19196       };
19197     } catch (Dali::DaliException e) {
19198       {
19199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19200       };
19201     } catch (...) {
19202       {
19203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19204       };
19205     }
19206   }
19207
19208   jresult = (void *)result;
19209   return jresult;
19210 }
19211
19212
19213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19214   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19215
19216   arg1 = (Dali::ObjectRegistry *)jarg1;
19217   {
19218     try {
19219       delete arg1;
19220     } catch (std::out_of_range& e) {
19221       {
19222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19223       };
19224     } catch (std::exception& e) {
19225       {
19226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19227       };
19228     } catch (Dali::DaliException e) {
19229       {
19230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19231       };
19232     } catch (...) {
19233       {
19234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19235       };
19236     }
19237   }
19238
19239 }
19240
19241
19242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19243   void * jresult ;
19244   Dali::ObjectRegistry *arg1 = 0 ;
19245   Dali::ObjectRegistry *result = 0 ;
19246
19247   arg1 = (Dali::ObjectRegistry *)jarg1;
19248   if (!arg1) {
19249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19250     return 0;
19251   }
19252   {
19253     try {
19254       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19255     } catch (std::out_of_range& e) {
19256       {
19257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19258       };
19259     } catch (std::exception& e) {
19260       {
19261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19262       };
19263     } catch (Dali::DaliException e) {
19264       {
19265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19266       };
19267     } catch (...) {
19268       {
19269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19270       };
19271     }
19272   }
19273
19274   jresult = (void *)result;
19275   return jresult;
19276 }
19277
19278
19279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19280   void * jresult ;
19281   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19282   Dali::ObjectRegistry *arg2 = 0 ;
19283   Dali::ObjectRegistry *result = 0 ;
19284
19285   arg1 = (Dali::ObjectRegistry *)jarg1;
19286   arg2 = (Dali::ObjectRegistry *)jarg2;
19287   if (!arg2) {
19288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19289     return 0;
19290   }
19291   {
19292     try {
19293       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19294     } catch (std::out_of_range& e) {
19295       {
19296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19297       };
19298     } catch (std::exception& e) {
19299       {
19300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19301       };
19302     } catch (Dali::DaliException e) {
19303       {
19304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19305       };
19306     } catch (...) {
19307       {
19308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19309       };
19310     }
19311   }
19312
19313   jresult = (void *)result;
19314   return jresult;
19315 }
19316
19317
19318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19319   void * jresult ;
19320   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19321   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19322
19323   arg1 = (Dali::ObjectRegistry *)jarg1;
19324   {
19325     try {
19326       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19327     } catch (std::out_of_range& e) {
19328       {
19329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19330       };
19331     } catch (std::exception& e) {
19332       {
19333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19334       };
19335     } catch (Dali::DaliException e) {
19336       {
19337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19338       };
19339     } catch (...) {
19340       {
19341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19342       };
19343     }
19344   }
19345
19346   jresult = (void *)result;
19347   return jresult;
19348 }
19349
19350
19351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19352   void * jresult ;
19353   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19354   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19355
19356   arg1 = (Dali::ObjectRegistry *)jarg1;
19357   {
19358     try {
19359       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19360     } catch (std::out_of_range& e) {
19361       {
19362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19363       };
19364     } catch (std::exception& e) {
19365       {
19366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19367       };
19368     } catch (Dali::DaliException e) {
19369       {
19370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19371       };
19372     } catch (...) {
19373       {
19374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19375       };
19376     }
19377   }
19378
19379   jresult = (void *)result;
19380   return jresult;
19381 }
19382
19383
19384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19385   void * jresult ;
19386   Dali::PropertyCondition *result = 0 ;
19387
19388   {
19389     try {
19390       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19391     } catch (std::out_of_range& e) {
19392       {
19393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19394       };
19395     } catch (std::exception& e) {
19396       {
19397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19398       };
19399     } catch (Dali::DaliException e) {
19400       {
19401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19402       };
19403     } catch (...) {
19404       {
19405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19406       };
19407     }
19408   }
19409
19410   jresult = (void *)result;
19411   return jresult;
19412 }
19413
19414
19415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19416   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19417
19418   arg1 = (Dali::PropertyCondition *)jarg1;
19419   {
19420     try {
19421       delete arg1;
19422     } catch (std::out_of_range& e) {
19423       {
19424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19425       };
19426     } catch (std::exception& e) {
19427       {
19428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19429       };
19430     } catch (Dali::DaliException e) {
19431       {
19432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19433       };
19434     } catch (...) {
19435       {
19436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19437       };
19438     }
19439   }
19440
19441 }
19442
19443
19444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19445   void * jresult ;
19446   Dali::PropertyCondition *arg1 = 0 ;
19447   Dali::PropertyCondition *result = 0 ;
19448
19449   arg1 = (Dali::PropertyCondition *)jarg1;
19450   if (!arg1) {
19451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19452     return 0;
19453   }
19454   {
19455     try {
19456       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19457     } catch (std::out_of_range& e) {
19458       {
19459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19460       };
19461     } catch (std::exception& e) {
19462       {
19463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19464       };
19465     } catch (Dali::DaliException e) {
19466       {
19467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19468       };
19469     } catch (...) {
19470       {
19471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19472       };
19473     }
19474   }
19475
19476   jresult = (void *)result;
19477   return jresult;
19478 }
19479
19480
19481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19482   void * jresult ;
19483   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19484   Dali::PropertyCondition *arg2 = 0 ;
19485   Dali::PropertyCondition *result = 0 ;
19486
19487   arg1 = (Dali::PropertyCondition *)jarg1;
19488   arg2 = (Dali::PropertyCondition *)jarg2;
19489   if (!arg2) {
19490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19491     return 0;
19492   }
19493   {
19494     try {
19495       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19496     } catch (std::out_of_range& e) {
19497       {
19498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19499       };
19500     } catch (std::exception& e) {
19501       {
19502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19503       };
19504     } catch (Dali::DaliException e) {
19505       {
19506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19507       };
19508     } catch (...) {
19509       {
19510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19511       };
19512     }
19513   }
19514
19515   jresult = (void *)result;
19516   return jresult;
19517 }
19518
19519
19520 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19521   unsigned long jresult ;
19522   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19523   std::size_t result;
19524
19525   arg1 = (Dali::PropertyCondition *)jarg1;
19526   {
19527     try {
19528       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19529     } catch (std::out_of_range& e) {
19530       {
19531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19532       };
19533     } catch (std::exception& e) {
19534       {
19535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19536       };
19537     } catch (...) {
19538       {
19539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19540       };
19541     }
19542   }
19543   jresult = (unsigned long)result;
19544   return jresult;
19545 }
19546
19547
19548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19549   float jresult ;
19550   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19551   std::size_t arg2 ;
19552   float result;
19553
19554   arg1 = (Dali::PropertyCondition *)jarg1;
19555   arg2 = (std::size_t)jarg2;
19556   {
19557     try {
19558       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19559     } catch (std::out_of_range& e) {
19560       {
19561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19562       };
19563     } catch (std::exception& e) {
19564       {
19565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19566       };
19567     } catch (...) {
19568       {
19569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19570       };
19571     }
19572   }
19573   jresult = result;
19574   return jresult;
19575 }
19576
19577
19578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19579   void * jresult ;
19580   float arg1 ;
19581   Dali::PropertyCondition result;
19582
19583   arg1 = (float)jarg1;
19584   {
19585     try {
19586       result = Dali::LessThanCondition(arg1);
19587     } catch (std::out_of_range& e) {
19588       {
19589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19590       };
19591     } catch (std::exception& e) {
19592       {
19593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19594       };
19595     } catch (Dali::DaliException e) {
19596       {
19597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19598       };
19599     } catch (...) {
19600       {
19601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19602       };
19603     }
19604   }
19605
19606   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19607   return jresult;
19608 }
19609
19610
19611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19612   void * jresult ;
19613   float arg1 ;
19614   Dali::PropertyCondition result;
19615
19616   arg1 = (float)jarg1;
19617   {
19618     try {
19619       result = Dali::GreaterThanCondition(arg1);
19620     } catch (std::out_of_range& e) {
19621       {
19622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19623       };
19624     } catch (std::exception& e) {
19625       {
19626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19627       };
19628     } catch (Dali::DaliException e) {
19629       {
19630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19631       };
19632     } catch (...) {
19633       {
19634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19635       };
19636     }
19637   }
19638
19639   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19640   return jresult;
19641 }
19642
19643
19644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19645   void * jresult ;
19646   float arg1 ;
19647   float arg2 ;
19648   Dali::PropertyCondition result;
19649
19650   arg1 = (float)jarg1;
19651   arg2 = (float)jarg2;
19652   {
19653     try {
19654       result = Dali::InsideCondition(arg1,arg2);
19655     } catch (std::out_of_range& e) {
19656       {
19657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19658       };
19659     } catch (std::exception& e) {
19660       {
19661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19662       };
19663     } catch (Dali::DaliException e) {
19664       {
19665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19666       };
19667     } catch (...) {
19668       {
19669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19670       };
19671     }
19672   }
19673
19674   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19675   return jresult;
19676 }
19677
19678
19679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19680   void * jresult ;
19681   float arg1 ;
19682   float arg2 ;
19683   Dali::PropertyCondition result;
19684
19685   arg1 = (float)jarg1;
19686   arg2 = (float)jarg2;
19687   {
19688     try {
19689       result = Dali::OutsideCondition(arg1,arg2);
19690     } catch (std::out_of_range& e) {
19691       {
19692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19693       };
19694     } catch (std::exception& e) {
19695       {
19696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19697       };
19698     } catch (Dali::DaliException e) {
19699       {
19700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19701       };
19702     } catch (...) {
19703       {
19704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19705       };
19706     }
19707   }
19708
19709   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19710   return jresult;
19711 }
19712
19713
19714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19715   void * jresult ;
19716   float arg1 ;
19717   float arg2 ;
19718   Dali::PropertyCondition result;
19719
19720   arg1 = (float)jarg1;
19721   arg2 = (float)jarg2;
19722   {
19723     try {
19724       result = Dali::StepCondition(arg1,arg2);
19725     } catch (std::out_of_range& e) {
19726       {
19727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19728       };
19729     } catch (std::exception& e) {
19730       {
19731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19732       };
19733     } catch (Dali::DaliException e) {
19734       {
19735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19736       };
19737     } catch (...) {
19738       {
19739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19740       };
19741     }
19742   }
19743
19744   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19745   return jresult;
19746 }
19747
19748
19749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19750   void * jresult ;
19751   float arg1 ;
19752   Dali::PropertyCondition result;
19753
19754   arg1 = (float)jarg1;
19755   {
19756     try {
19757       result = Dali::StepCondition(arg1);
19758     } catch (std::out_of_range& e) {
19759       {
19760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19761       };
19762     } catch (std::exception& e) {
19763       {
19764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19765       };
19766     } catch (Dali::DaliException e) {
19767       {
19768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19769       };
19770     } catch (...) {
19771       {
19772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19773       };
19774     }
19775   }
19776
19777   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19778   return jresult;
19779 }
19780
19781
19782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19783   void * jresult ;
19784   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19785   Dali::PropertyCondition result;
19786
19787   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19788   if (!arg1) {
19789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19790     return 0;
19791   }
19792   {
19793     try {
19794       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19795     } catch (std::out_of_range& e) {
19796       {
19797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19798       };
19799     } catch (std::exception& e) {
19800       {
19801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19802       };
19803     } catch (Dali::DaliException e) {
19804       {
19805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19806       };
19807     } catch (...) {
19808       {
19809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19810       };
19811     }
19812   }
19813
19814   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19815   return jresult;
19816 }
19817
19818
19819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19820   void * jresult ;
19821   Dali::PropertyNotification *result = 0 ;
19822
19823   {
19824     try {
19825       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19826     } catch (std::out_of_range& e) {
19827       {
19828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19829       };
19830     } catch (std::exception& e) {
19831       {
19832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19833       };
19834     } catch (Dali::DaliException e) {
19835       {
19836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19837       };
19838     } catch (...) {
19839       {
19840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19841       };
19842     }
19843   }
19844
19845   jresult = (void *)result;
19846   return jresult;
19847 }
19848
19849
19850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19851   void * jresult ;
19852   Dali::BaseHandle arg1 ;
19853   Dali::BaseHandle *argp1 ;
19854   Dali::PropertyNotification result;
19855
19856   argp1 = (Dali::BaseHandle *)jarg1;
19857   if (!argp1) {
19858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19859     return 0;
19860   }
19861   arg1 = *argp1;
19862   {
19863     try {
19864       result = Dali::PropertyNotification::DownCast(arg1);
19865     } catch (std::out_of_range& e) {
19866       {
19867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19868       };
19869     } catch (std::exception& e) {
19870       {
19871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19872       };
19873     } catch (Dali::DaliException e) {
19874       {
19875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19876       };
19877     } catch (...) {
19878       {
19879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19880       };
19881     }
19882   }
19883
19884   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19885   return jresult;
19886 }
19887
19888
19889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19890   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19891
19892   arg1 = (Dali::PropertyNotification *)jarg1;
19893   {
19894     try {
19895       delete arg1;
19896     } catch (std::out_of_range& e) {
19897       {
19898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19899       };
19900     } catch (std::exception& e) {
19901       {
19902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19903       };
19904     } catch (Dali::DaliException e) {
19905       {
19906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19907       };
19908     } catch (...) {
19909       {
19910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19911       };
19912     }
19913   }
19914
19915 }
19916
19917
19918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19919   void * jresult ;
19920   Dali::PropertyNotification *arg1 = 0 ;
19921   Dali::PropertyNotification *result = 0 ;
19922
19923   arg1 = (Dali::PropertyNotification *)jarg1;
19924   if (!arg1) {
19925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19926     return 0;
19927   }
19928   {
19929     try {
19930       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19931     } catch (std::out_of_range& e) {
19932       {
19933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19934       };
19935     } catch (std::exception& e) {
19936       {
19937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19938       };
19939     } catch (Dali::DaliException e) {
19940       {
19941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19942       };
19943     } catch (...) {
19944       {
19945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19946       };
19947     }
19948   }
19949
19950   jresult = (void *)result;
19951   return jresult;
19952 }
19953
19954
19955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19956   void * jresult ;
19957   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19958   Dali::PropertyNotification *arg2 = 0 ;
19959   Dali::PropertyNotification *result = 0 ;
19960
19961   arg1 = (Dali::PropertyNotification *)jarg1;
19962   arg2 = (Dali::PropertyNotification *)jarg2;
19963   if (!arg2) {
19964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19965     return 0;
19966   }
19967   {
19968     try {
19969       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19970     } catch (std::out_of_range& e) {
19971       {
19972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19973       };
19974     } catch (std::exception& e) {
19975       {
19976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19977       };
19978     } catch (Dali::DaliException e) {
19979       {
19980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19981       };
19982     } catch (...) {
19983       {
19984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19985       };
19986     }
19987   }
19988
19989   jresult = (void *)result;
19990   return jresult;
19991 }
19992
19993
19994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19995   void * jresult ;
19996   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19997   Dali::PropertyCondition result;
19998
19999   arg1 = (Dali::PropertyNotification *)jarg1;
20000   {
20001     try {
20002       result = (arg1)->GetCondition();
20003     } catch (std::out_of_range& e) {
20004       {
20005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20006       };
20007     } catch (std::exception& e) {
20008       {
20009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20010       };
20011     } catch (Dali::DaliException e) {
20012       {
20013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20014       };
20015     } catch (...) {
20016       {
20017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20018       };
20019     }
20020   }
20021
20022   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20023   return jresult;
20024 }
20025
20026
20027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20028   void * jresult ;
20029   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20030   Dali::Handle result;
20031
20032   arg1 = (Dali::PropertyNotification *)jarg1;
20033   {
20034     try {
20035       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20036     } catch (std::out_of_range& e) {
20037       {
20038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20039       };
20040     } catch (std::exception& e) {
20041       {
20042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20043       };
20044     } catch (Dali::DaliException e) {
20045       {
20046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20047       };
20048     } catch (...) {
20049       {
20050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20051       };
20052     }
20053   }
20054
20055   jresult = new Dali::Handle((const Dali::Handle &)result);
20056   return jresult;
20057 }
20058
20059
20060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20061   int jresult ;
20062   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20063   Dali::Property::Index result;
20064
20065   arg1 = (Dali::PropertyNotification *)jarg1;
20066   {
20067     try {
20068       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20069     } catch (std::out_of_range& e) {
20070       {
20071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20072       };
20073     } catch (std::exception& e) {
20074       {
20075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20076       };
20077     } catch (Dali::DaliException e) {
20078       {
20079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20080       };
20081     } catch (...) {
20082       {
20083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20084       };
20085     }
20086   }
20087
20088   jresult = result;
20089   return jresult;
20090 }
20091
20092
20093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20094   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20095   Dali::PropertyNotification::NotifyMode arg2 ;
20096
20097   arg1 = (Dali::PropertyNotification *)jarg1;
20098   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20099   {
20100     try {
20101       (arg1)->SetNotifyMode(arg2);
20102     } catch (std::out_of_range& e) {
20103       {
20104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20105       };
20106     } catch (std::exception& e) {
20107       {
20108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20109       };
20110     } catch (Dali::DaliException e) {
20111       {
20112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20113       };
20114     } catch (...) {
20115       {
20116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20117       };
20118     }
20119   }
20120
20121 }
20122
20123
20124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20125   int jresult ;
20126   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20127   Dali::PropertyNotification::NotifyMode result;
20128
20129   arg1 = (Dali::PropertyNotification *)jarg1;
20130   {
20131     try {
20132       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20133     } catch (std::out_of_range& e) {
20134       {
20135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20136       };
20137     } catch (std::exception& e) {
20138       {
20139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20140       };
20141     } catch (Dali::DaliException e) {
20142       {
20143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20144       };
20145     } catch (...) {
20146       {
20147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20148       };
20149     }
20150   }
20151
20152   jresult = (int)result;
20153   return jresult;
20154 }
20155
20156
20157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20158   unsigned int jresult ;
20159   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20160   bool result;
20161
20162   arg1 = (Dali::PropertyNotification *)jarg1;
20163   {
20164     try {
20165       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20166     } catch (std::out_of_range& e) {
20167       {
20168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20169       };
20170     } catch (std::exception& e) {
20171       {
20172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20173       };
20174     } catch (Dali::DaliException e) {
20175       {
20176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20177       };
20178     } catch (...) {
20179       {
20180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20181       };
20182     }
20183   }
20184
20185   jresult = result;
20186   return jresult;
20187 }
20188
20189
20190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20191   void * jresult ;
20192   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20193   Dali::PropertyNotifySignalType *result = 0 ;
20194
20195   arg1 = (Dali::PropertyNotification *)jarg1;
20196   {
20197     try {
20198       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20199     } catch (std::out_of_range& e) {
20200       {
20201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20202       };
20203     } catch (std::exception& e) {
20204       {
20205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20206       };
20207     } catch (Dali::DaliException e) {
20208       {
20209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20210       };
20211     } catch (...) {
20212       {
20213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20214       };
20215     }
20216   }
20217
20218   jresult = (void *)result;
20219   return jresult;
20220 }
20221
20222
20223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20224   void * jresult ;
20225   Dali::Handle *result = 0 ;
20226
20227   {
20228     try {
20229       result = (Dali::Handle *)new Dali::Handle();
20230     } catch (std::out_of_range& e) {
20231       {
20232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20233       };
20234     } catch (std::exception& e) {
20235       {
20236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20237       };
20238     } catch (Dali::DaliException e) {
20239       {
20240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20241       };
20242     } catch (...) {
20243       {
20244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20245       };
20246     }
20247   }
20248
20249   jresult = (void *)result;
20250   return jresult;
20251 }
20252
20253
20254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20255   void * jresult ;
20256   Dali::Handle result;
20257
20258   {
20259     try {
20260       result = Dali::Handle::New();
20261     } catch (std::out_of_range& e) {
20262       {
20263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20264       };
20265     } catch (std::exception& e) {
20266       {
20267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20268       };
20269     } catch (Dali::DaliException e) {
20270       {
20271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20272       };
20273     } catch (...) {
20274       {
20275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20276       };
20277     }
20278   }
20279
20280   jresult = new Dali::Handle((const Dali::Handle &)result);
20281   return jresult;
20282 }
20283
20284
20285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20286   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20287
20288   arg1 = (Dali::Handle *)jarg1;
20289   {
20290     try {
20291       delete arg1;
20292     } catch (std::out_of_range& e) {
20293       {
20294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20295       };
20296     } catch (std::exception& e) {
20297       {
20298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20299       };
20300     } catch (Dali::DaliException e) {
20301       {
20302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20303       };
20304     } catch (...) {
20305       {
20306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20307       };
20308     }
20309   }
20310
20311 }
20312
20313
20314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20315   void * jresult ;
20316   Dali::Handle *arg1 = 0 ;
20317   Dali::Handle *result = 0 ;
20318
20319   arg1 = (Dali::Handle *)jarg1;
20320   if (!arg1) {
20321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20322     return 0;
20323   }
20324   {
20325     try {
20326       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20327     } catch (std::out_of_range& e) {
20328       {
20329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20330       };
20331     } catch (std::exception& e) {
20332       {
20333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20334       };
20335     } catch (Dali::DaliException e) {
20336       {
20337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20338       };
20339     } catch (...) {
20340       {
20341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20342       };
20343     }
20344   }
20345
20346   jresult = (void *)result;
20347   return jresult;
20348 }
20349
20350
20351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20352   void * jresult ;
20353   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20354   Dali::Handle *arg2 = 0 ;
20355   Dali::Handle *result = 0 ;
20356
20357   arg1 = (Dali::Handle *)jarg1;
20358   arg2 = (Dali::Handle *)jarg2;
20359   if (!arg2) {
20360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20361     return 0;
20362   }
20363   {
20364     try {
20365       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20366     } catch (std::out_of_range& e) {
20367       {
20368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20369       };
20370     } catch (std::exception& e) {
20371       {
20372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20373       };
20374     } catch (Dali::DaliException e) {
20375       {
20376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20377       };
20378     } catch (...) {
20379       {
20380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20381       };
20382     }
20383   }
20384
20385   jresult = (void *)result;
20386   return jresult;
20387 }
20388
20389
20390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20391   void * jresult ;
20392   Dali::BaseHandle arg1 ;
20393   Dali::BaseHandle *argp1 ;
20394   Dali::Handle result;
20395
20396   argp1 = (Dali::BaseHandle *)jarg1;
20397   if (!argp1) {
20398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20399     return 0;
20400   }
20401   arg1 = *argp1;
20402   {
20403     try {
20404       result = Dali::Handle::DownCast(arg1);
20405     } catch (std::out_of_range& e) {
20406       {
20407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20408       };
20409     } catch (std::exception& e) {
20410       {
20411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20412       };
20413     } catch (Dali::DaliException e) {
20414       {
20415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20416       };
20417     } catch (...) {
20418       {
20419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20420       };
20421     }
20422   }
20423
20424   jresult = new Dali::Handle((const Dali::Handle &)result);
20425   return jresult;
20426 }
20427
20428
20429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20430   unsigned int jresult ;
20431   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20432   Dali::Handle::Capability arg2 ;
20433   bool result;
20434
20435   arg1 = (Dali::Handle *)jarg1;
20436   arg2 = (Dali::Handle::Capability)jarg2;
20437   {
20438     try {
20439       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20440     } catch (std::out_of_range& e) {
20441       {
20442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20443       };
20444     } catch (std::exception& e) {
20445       {
20446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20447       };
20448     } catch (Dali::DaliException e) {
20449       {
20450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20451       };
20452     } catch (...) {
20453       {
20454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20455       };
20456     }
20457   }
20458
20459   jresult = result;
20460   return jresult;
20461 }
20462
20463
20464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20465   unsigned int jresult ;
20466   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20467   unsigned int result;
20468
20469   arg1 = (Dali::Handle *)jarg1;
20470   {
20471     try {
20472       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20473     } catch (std::out_of_range& e) {
20474       {
20475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20476       };
20477     } catch (std::exception& e) {
20478       {
20479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20480       };
20481     } catch (Dali::DaliException e) {
20482       {
20483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20484       };
20485     } catch (...) {
20486       {
20487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20488       };
20489     }
20490   }
20491
20492   jresult = result;
20493   return jresult;
20494 }
20495
20496
20497 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20498   char * jresult ;
20499   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20500   Dali::Property::Index arg2 ;
20501   std::string result;
20502
20503   arg1 = (Dali::Handle *)jarg1;
20504   arg2 = (Dali::Property::Index)jarg2;
20505   {
20506     try {
20507       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20508     } catch (std::out_of_range& e) {
20509       {
20510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20511       };
20512     } catch (std::exception& e) {
20513       {
20514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20515       };
20516     } catch (Dali::DaliException e) {
20517       {
20518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20519       };
20520     } catch (...) {
20521       {
20522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20523       };
20524     }
20525   }
20526
20527   jresult = SWIG_csharp_string_callback((&result)->c_str());
20528   return jresult;
20529 }
20530
20531
20532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20533   int jresult ;
20534   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20535   std::string *arg2 = 0 ;
20536   Dali::Property::Index result;
20537
20538   arg1 = (Dali::Handle *)jarg1;
20539   if (!jarg2) {
20540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20541     return 0;
20542   }
20543   std::string arg2_str(jarg2);
20544   arg2 = &arg2_str;
20545   {
20546     try {
20547       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20548     } catch (std::out_of_range& e) {
20549       {
20550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20551       };
20552     } catch (std::exception& e) {
20553       {
20554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20555       };
20556     } catch (Dali::DaliException e) {
20557       {
20558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20559       };
20560     } catch (...) {
20561       {
20562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20563       };
20564     }
20565   }
20566
20567   jresult = result;
20568
20569   //argout typemap for const std::string&
20570
20571   return jresult;
20572 }
20573
20574
20575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20576   unsigned int jresult ;
20577   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20578   Dali::Property::Index arg2 ;
20579   bool result;
20580
20581   arg1 = (Dali::Handle *)jarg1;
20582   arg2 = (Dali::Property::Index)jarg2;
20583   {
20584     try {
20585       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20586     } catch (std::out_of_range& e) {
20587       {
20588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20589       };
20590     } catch (std::exception& e) {
20591       {
20592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20593       };
20594     } catch (Dali::DaliException e) {
20595       {
20596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20597       };
20598     } catch (...) {
20599       {
20600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20601       };
20602     }
20603   }
20604
20605   jresult = result;
20606   return jresult;
20607 }
20608
20609
20610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20611   unsigned int jresult ;
20612   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20613   Dali::Property::Index arg2 ;
20614   bool result;
20615
20616   arg1 = (Dali::Handle *)jarg1;
20617   arg2 = (Dali::Property::Index)jarg2;
20618   {
20619     try {
20620       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20621     } catch (std::out_of_range& e) {
20622       {
20623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20624       };
20625     } catch (std::exception& e) {
20626       {
20627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20628       };
20629     } catch (Dali::DaliException e) {
20630       {
20631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20632       };
20633     } catch (...) {
20634       {
20635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20636       };
20637     }
20638   }
20639
20640   jresult = result;
20641   return jresult;
20642 }
20643
20644
20645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20646   unsigned int jresult ;
20647   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20648   Dali::Property::Index arg2 ;
20649   bool result;
20650
20651   arg1 = (Dali::Handle *)jarg1;
20652   arg2 = (Dali::Property::Index)jarg2;
20653   {
20654     try {
20655       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20656     } catch (std::out_of_range& e) {
20657       {
20658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20659       };
20660     } catch (std::exception& e) {
20661       {
20662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20663       };
20664     } catch (Dali::DaliException e) {
20665       {
20666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20667       };
20668     } catch (...) {
20669       {
20670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20671       };
20672     }
20673   }
20674
20675   jresult = result;
20676   return jresult;
20677 }
20678
20679
20680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20681   int jresult ;
20682   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20683   Dali::Property::Index arg2 ;
20684   Dali::Property::Type result;
20685
20686   arg1 = (Dali::Handle *)jarg1;
20687   arg2 = (Dali::Property::Index)jarg2;
20688   {
20689     try {
20690       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20691     } catch (std::out_of_range& e) {
20692       {
20693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20694       };
20695     } catch (std::exception& e) {
20696       {
20697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20698       };
20699     } catch (Dali::DaliException e) {
20700       {
20701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20702       };
20703     } catch (...) {
20704       {
20705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20706       };
20707     }
20708   }
20709
20710   jresult = (int)result;
20711   return jresult;
20712 }
20713
20714
20715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20716   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20717   Dali::Property::Index arg2 ;
20718   Dali::Property::Value *arg3 = 0 ;
20719
20720   arg1 = (Dali::Handle *)jarg1;
20721   arg2 = (Dali::Property::Index)jarg2;
20722   arg3 = (Dali::Property::Value *)jarg3;
20723   if (!arg3) {
20724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20725     return ;
20726   }
20727   {
20728     try {
20729       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20730     } catch (std::out_of_range& e) {
20731       {
20732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20733       };
20734     } catch (std::exception& e) {
20735       {
20736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20737       };
20738     } catch (Dali::DaliException e) {
20739       {
20740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20741       };
20742     } catch (...) {
20743       {
20744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20745       };
20746     }
20747   }
20748
20749 }
20750
20751
20752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20753   int jresult ;
20754   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20755   std::string *arg2 = 0 ;
20756   Dali::Property::Value *arg3 = 0 ;
20757   Dali::Property::Index result;
20758
20759   arg1 = (Dali::Handle *)jarg1;
20760   if (!jarg2) {
20761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20762     return 0;
20763   }
20764   std::string arg2_str(jarg2);
20765   arg2 = &arg2_str;
20766   arg3 = (Dali::Property::Value *)jarg3;
20767   if (!arg3) {
20768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20769     return 0;
20770   }
20771   {
20772     try {
20773       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20774     } catch (std::out_of_range& e) {
20775       {
20776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20777       };
20778     } catch (std::exception& e) {
20779       {
20780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20781       };
20782     } catch (Dali::DaliException e) {
20783       {
20784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20785       };
20786     } catch (...) {
20787       {
20788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20789       };
20790     }
20791   }
20792
20793   jresult = result;
20794
20795   //argout typemap for const std::string&
20796
20797   return jresult;
20798 }
20799
20800
20801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20802   int jresult ;
20803   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20804   std::string *arg2 = 0 ;
20805   Dali::Property::Value *arg3 = 0 ;
20806   Dali::Property::AccessMode arg4 ;
20807   Dali::Property::Index result;
20808
20809   arg1 = (Dali::Handle *)jarg1;
20810   if (!jarg2) {
20811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20812     return 0;
20813   }
20814   std::string arg2_str(jarg2);
20815   arg2 = &arg2_str;
20816   arg3 = (Dali::Property::Value *)jarg3;
20817   if (!arg3) {
20818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20819     return 0;
20820   }
20821   arg4 = (Dali::Property::AccessMode)jarg4;
20822   {
20823     try {
20824       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20825     } catch (std::out_of_range& e) {
20826       {
20827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20828       };
20829     } catch (std::exception& e) {
20830       {
20831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20832       };
20833     } catch (Dali::DaliException e) {
20834       {
20835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20836       };
20837     } catch (...) {
20838       {
20839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20840       };
20841     }
20842   }
20843
20844   jresult = result;
20845
20846   //argout typemap for const std::string&
20847
20848   return jresult;
20849 }
20850
20851
20852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20853   void * jresult ;
20854   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20855   Dali::Property::Index arg2 ;
20856   Dali::Property::Value result;
20857
20858   arg1 = (Dali::Handle *)jarg1;
20859   arg2 = (Dali::Property::Index)jarg2;
20860   {
20861     try {
20862       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20863     } catch (std::out_of_range& e) {
20864       {
20865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20866       };
20867     } catch (std::exception& e) {
20868       {
20869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20870       };
20871     } catch (Dali::DaliException e) {
20872       {
20873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20874       };
20875     } catch (...) {
20876       {
20877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20878       };
20879     }
20880   }
20881
20882   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20883   return jresult;
20884 }
20885
20886
20887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20888   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20889   Dali::Property::IndexContainer *arg2 = 0 ;
20890
20891   arg1 = (Dali::Handle *)jarg1;
20892   arg2 = (Dali::Property::IndexContainer *)jarg2;
20893   if (!arg2) {
20894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20895     return ;
20896   }
20897   {
20898     try {
20899       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20900     } catch (std::out_of_range& e) {
20901       {
20902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20903       };
20904     } catch (std::exception& e) {
20905       {
20906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20907       };
20908     } catch (Dali::DaliException e) {
20909       {
20910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20911       };
20912     } catch (...) {
20913       {
20914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20915       };
20916     }
20917   }
20918
20919 }
20920
20921
20922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20923   void * jresult ;
20924   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20925   Dali::Property::Index arg2 ;
20926   Dali::PropertyCondition *arg3 = 0 ;
20927   Dali::PropertyNotification result;
20928
20929   arg1 = (Dali::Handle *)jarg1;
20930   arg2 = (Dali::Property::Index)jarg2;
20931   arg3 = (Dali::PropertyCondition *)jarg3;
20932   if (!arg3) {
20933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20934     return 0;
20935   }
20936   {
20937     try {
20938       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20939     } catch (std::out_of_range& e) {
20940       {
20941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20942       };
20943     } catch (std::exception& e) {
20944       {
20945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20946       };
20947     } catch (Dali::DaliException e) {
20948       {
20949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20950       };
20951     } catch (...) {
20952       {
20953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20954       };
20955     }
20956   }
20957
20958   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20959   return jresult;
20960 }
20961
20962
20963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20964   void * jresult ;
20965   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20966   Dali::Property::Index arg2 ;
20967   int arg3 ;
20968   Dali::PropertyCondition *arg4 = 0 ;
20969   Dali::PropertyNotification result;
20970
20971   arg1 = (Dali::Handle *)jarg1;
20972   arg2 = (Dali::Property::Index)jarg2;
20973   arg3 = (int)jarg3;
20974   arg4 = (Dali::PropertyCondition *)jarg4;
20975   if (!arg4) {
20976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20977     return 0;
20978   }
20979   {
20980     try {
20981       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20982     } catch (std::out_of_range& e) {
20983       {
20984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20985       };
20986     } catch (std::exception& e) {
20987       {
20988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20989       };
20990     } catch (Dali::DaliException e) {
20991       {
20992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20993       };
20994     } catch (...) {
20995       {
20996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20997       };
20998     }
20999   }
21000
21001   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21002   return jresult;
21003 }
21004
21005
21006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21007   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21008   Dali::PropertyNotification arg2 ;
21009   Dali::PropertyNotification *argp2 ;
21010
21011   arg1 = (Dali::Handle *)jarg1;
21012   argp2 = (Dali::PropertyNotification *)jarg2;
21013   if (!argp2) {
21014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21015     return ;
21016   }
21017   arg2 = *argp2;
21018   {
21019     try {
21020       (arg1)->RemovePropertyNotification(arg2);
21021     } catch (std::out_of_range& e) {
21022       {
21023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21024       };
21025     } catch (std::exception& e) {
21026       {
21027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21028       };
21029     } catch (Dali::DaliException e) {
21030       {
21031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21032       };
21033     } catch (...) {
21034       {
21035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21036       };
21037     }
21038   }
21039
21040 }
21041
21042
21043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21044   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21045
21046   arg1 = (Dali::Handle *)jarg1;
21047   {
21048     try {
21049       (arg1)->RemovePropertyNotifications();
21050     } catch (std::out_of_range& e) {
21051       {
21052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21053       };
21054     } catch (std::exception& e) {
21055       {
21056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21057       };
21058     } catch (Dali::DaliException e) {
21059       {
21060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21061       };
21062     } catch (...) {
21063       {
21064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21065       };
21066     }
21067   }
21068
21069 }
21070
21071
21072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21073   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21074
21075   arg1 = (Dali::Handle *)jarg1;
21076   {
21077     try {
21078       (arg1)->RemoveConstraints();
21079     } catch (std::out_of_range& e) {
21080       {
21081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21082       };
21083     } catch (std::exception& e) {
21084       {
21085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21086       };
21087     } catch (Dali::DaliException e) {
21088       {
21089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21090       };
21091     } catch (...) {
21092       {
21093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21094       };
21095     }
21096   }
21097
21098 }
21099
21100
21101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21102   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21103   unsigned int arg2 ;
21104
21105   arg1 = (Dali::Handle *)jarg1;
21106   arg2 = (unsigned int)jarg2;
21107   {
21108     try {
21109       (arg1)->RemoveConstraints(arg2);
21110     } catch (std::out_of_range& e) {
21111       {
21112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21113       };
21114     } catch (std::exception& e) {
21115       {
21116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21117       };
21118     } catch (Dali::DaliException e) {
21119       {
21120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21121       };
21122     } catch (...) {
21123       {
21124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21125       };
21126     }
21127   }
21128
21129 }
21130
21131
21132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21133   int jresult ;
21134   Dali::Property::Index result;
21135
21136   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21137   jresult = result;
21138   return jresult;
21139 }
21140
21141
21142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21143   void * jresult ;
21144   Dali::Handle result;
21145
21146   {
21147     try {
21148       result = Dali::WeightObject::New();
21149     } catch (std::out_of_range& e) {
21150       {
21151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21152       };
21153     } catch (std::exception& e) {
21154       {
21155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21156       };
21157     } catch (Dali::DaliException e) {
21158       {
21159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21160       };
21161     } catch (...) {
21162       {
21163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21164       };
21165     }
21166   }
21167
21168   jresult = new Dali::Handle((const Dali::Handle &)result);
21169   return jresult;
21170 }
21171
21172
21173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21174   void * jresult ;
21175   Dali::TypeInfo *result = 0 ;
21176
21177   {
21178     try {
21179       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21180     } catch (std::out_of_range& e) {
21181       {
21182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21183       };
21184     } catch (std::exception& e) {
21185       {
21186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21187       };
21188     } catch (Dali::DaliException e) {
21189       {
21190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21191       };
21192     } catch (...) {
21193       {
21194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21195       };
21196     }
21197   }
21198
21199   jresult = (void *)result;
21200   return jresult;
21201 }
21202
21203
21204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21205   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21206
21207   arg1 = (Dali::TypeInfo *)jarg1;
21208   {
21209     try {
21210       delete arg1;
21211     } catch (std::out_of_range& e) {
21212       {
21213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21214       };
21215     } catch (std::exception& e) {
21216       {
21217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21218       };
21219     } catch (Dali::DaliException e) {
21220       {
21221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21222       };
21223     } catch (...) {
21224       {
21225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21226       };
21227     }
21228   }
21229
21230 }
21231
21232
21233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21234   void * jresult ;
21235   Dali::TypeInfo *arg1 = 0 ;
21236   Dali::TypeInfo *result = 0 ;
21237
21238   arg1 = (Dali::TypeInfo *)jarg1;
21239   if (!arg1) {
21240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21241     return 0;
21242   }
21243   {
21244     try {
21245       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21246     } catch (std::out_of_range& e) {
21247       {
21248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21249       };
21250     } catch (std::exception& e) {
21251       {
21252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21253       };
21254     } catch (Dali::DaliException e) {
21255       {
21256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21257       };
21258     } catch (...) {
21259       {
21260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21261       };
21262     }
21263   }
21264
21265   jresult = (void *)result;
21266   return jresult;
21267 }
21268
21269
21270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21271   void * jresult ;
21272   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21273   Dali::TypeInfo *arg2 = 0 ;
21274   Dali::TypeInfo *result = 0 ;
21275
21276   arg1 = (Dali::TypeInfo *)jarg1;
21277   arg2 = (Dali::TypeInfo *)jarg2;
21278   if (!arg2) {
21279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21280     return 0;
21281   }
21282   {
21283     try {
21284       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21285     } catch (std::out_of_range& e) {
21286       {
21287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21288       };
21289     } catch (std::exception& e) {
21290       {
21291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21292       };
21293     } catch (Dali::DaliException e) {
21294       {
21295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21296       };
21297     } catch (...) {
21298       {
21299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21300       };
21301     }
21302   }
21303
21304   jresult = (void *)result;
21305   return jresult;
21306 }
21307
21308
21309 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21310   char * jresult ;
21311   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21312   std::string *result = 0 ;
21313
21314   arg1 = (Dali::TypeInfo *)jarg1;
21315   {
21316     try {
21317       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21318     } catch (std::out_of_range& e) {
21319       {
21320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21321       };
21322     } catch (std::exception& e) {
21323       {
21324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21325       };
21326     } catch (Dali::DaliException e) {
21327       {
21328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21329       };
21330     } catch (...) {
21331       {
21332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21333       };
21334     }
21335   }
21336
21337   jresult = SWIG_csharp_string_callback(result->c_str());
21338   return jresult;
21339 }
21340
21341
21342 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21343   char * jresult ;
21344   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21345   std::string *result = 0 ;
21346
21347   arg1 = (Dali::TypeInfo *)jarg1;
21348   {
21349     try {
21350       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21351     } catch (std::out_of_range& e) {
21352       {
21353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21354       };
21355     } catch (std::exception& e) {
21356       {
21357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21358       };
21359     } catch (Dali::DaliException e) {
21360       {
21361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21362       };
21363     } catch (...) {
21364       {
21365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21366       };
21367     }
21368   }
21369
21370   jresult = SWIG_csharp_string_callback(result->c_str());
21371   return jresult;
21372 }
21373
21374
21375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21376   void * jresult ;
21377   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21378   Dali::BaseHandle result;
21379
21380   arg1 = (Dali::TypeInfo *)jarg1;
21381   {
21382     try {
21383       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21384     } catch (std::out_of_range& e) {
21385       {
21386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21387       };
21388     } catch (std::exception& e) {
21389       {
21390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21391       };
21392     } catch (Dali::DaliException e) {
21393       {
21394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21395       };
21396     } catch (...) {
21397       {
21398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21399       };
21400     }
21401   }
21402
21403   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21404   return jresult;
21405 }
21406
21407
21408 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21409   unsigned long jresult ;
21410   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21411   size_t result;
21412
21413   arg1 = (Dali::TypeInfo *)jarg1;
21414   {
21415     try {
21416       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21417     } catch (std::out_of_range& e) {
21418       {
21419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21420       };
21421     } catch (std::exception& e) {
21422       {
21423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21424       };
21425     } catch (Dali::DaliException e) {
21426       {
21427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21428       };
21429     } catch (...) {
21430       {
21431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21432       };
21433     }
21434   }
21435
21436   jresult = (unsigned long)result;
21437   return jresult;
21438 }
21439
21440
21441 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21442   char * jresult ;
21443   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21444   size_t arg2 ;
21445   std::string result;
21446
21447   arg1 = (Dali::TypeInfo *)jarg1;
21448   arg2 = (size_t)jarg2;
21449   {
21450     try {
21451       result = (arg1)->GetActionName(arg2);
21452     } catch (std::out_of_range& e) {
21453       {
21454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21455       };
21456     } catch (std::exception& e) {
21457       {
21458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21459       };
21460     } catch (Dali::DaliException e) {
21461       {
21462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21463       };
21464     } catch (...) {
21465       {
21466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21467       };
21468     }
21469   }
21470
21471   jresult = SWIG_csharp_string_callback((&result)->c_str());
21472   return jresult;
21473 }
21474
21475
21476 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21477   unsigned long jresult ;
21478   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21479   size_t result;
21480
21481   arg1 = (Dali::TypeInfo *)jarg1;
21482   {
21483     try {
21484       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21485     } catch (std::out_of_range& e) {
21486       {
21487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21488       };
21489     } catch (std::exception& e) {
21490       {
21491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21492       };
21493     } catch (Dali::DaliException e) {
21494       {
21495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21496       };
21497     } catch (...) {
21498       {
21499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21500       };
21501     }
21502   }
21503
21504   jresult = (unsigned long)result;
21505   return jresult;
21506 }
21507
21508
21509 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21510   char * jresult ;
21511   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21512   size_t arg2 ;
21513   std::string result;
21514
21515   arg1 = (Dali::TypeInfo *)jarg1;
21516   arg2 = (size_t)jarg2;
21517   {
21518     try {
21519       result = (arg1)->GetSignalName(arg2);
21520     } catch (std::out_of_range& e) {
21521       {
21522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21523       };
21524     } catch (std::exception& e) {
21525       {
21526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21527       };
21528     } catch (Dali::DaliException e) {
21529       {
21530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21531       };
21532     } catch (...) {
21533       {
21534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21535       };
21536     }
21537   }
21538
21539   jresult = SWIG_csharp_string_callback((&result)->c_str());
21540   return jresult;
21541 }
21542
21543
21544 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21545   unsigned long jresult ;
21546   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21547   size_t result;
21548
21549   arg1 = (Dali::TypeInfo *)jarg1;
21550   {
21551     try {
21552       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21553     } catch (std::out_of_range& e) {
21554       {
21555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21556       };
21557     } catch (std::exception& e) {
21558       {
21559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21560       };
21561     } catch (Dali::DaliException e) {
21562       {
21563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21564       };
21565     } catch (...) {
21566       {
21567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21568       };
21569     }
21570   }
21571
21572   jresult = (unsigned long)result;
21573   return jresult;
21574 }
21575
21576
21577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21578   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21579   Dali::Property::IndexContainer *arg2 = 0 ;
21580
21581   arg1 = (Dali::TypeInfo *)jarg1;
21582   arg2 = (Dali::Property::IndexContainer *)jarg2;
21583   if (!arg2) {
21584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21585     return ;
21586   }
21587   {
21588     try {
21589       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21590     } catch (std::out_of_range& e) {
21591       {
21592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21593       };
21594     } catch (std::exception& e) {
21595       {
21596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21597       };
21598     } catch (Dali::DaliException e) {
21599       {
21600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21601       };
21602     } catch (...) {
21603       {
21604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21605       };
21606     }
21607   }
21608
21609 }
21610
21611
21612 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21613   char * jresult ;
21614   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21615   Dali::Property::Index arg2 ;
21616   std::string *result = 0 ;
21617
21618   arg1 = (Dali::TypeInfo *)jarg1;
21619   arg2 = (Dali::Property::Index)jarg2;
21620   {
21621     try {
21622       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21623     } catch (std::out_of_range& e) {
21624       {
21625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21626       };
21627     } catch (std::exception& e) {
21628       {
21629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21630       };
21631     } catch (Dali::DaliException e) {
21632       {
21633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21634       };
21635     } catch (...) {
21636       {
21637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21638       };
21639     }
21640   }
21641
21642   jresult = SWIG_csharp_string_callback(result->c_str());
21643   return jresult;
21644 }
21645
21646
21647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21648   void * jresult ;
21649   Dali::TypeRegistry result;
21650
21651   {
21652     try {
21653       result = Dali::TypeRegistry::Get();
21654     } catch (std::out_of_range& e) {
21655       {
21656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21657       };
21658     } catch (std::exception& e) {
21659       {
21660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21661       };
21662     } catch (Dali::DaliException e) {
21663       {
21664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21665       };
21666     } catch (...) {
21667       {
21668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21669       };
21670     }
21671   }
21672
21673   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21674   return jresult;
21675 }
21676
21677
21678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21679   void * jresult ;
21680   Dali::TypeRegistry *result = 0 ;
21681
21682   {
21683     try {
21684       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21685     } catch (std::out_of_range& e) {
21686       {
21687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21688       };
21689     } catch (std::exception& e) {
21690       {
21691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21692       };
21693     } catch (Dali::DaliException e) {
21694       {
21695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21696       };
21697     } catch (...) {
21698       {
21699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21700       };
21701     }
21702   }
21703
21704   jresult = (void *)result;
21705   return jresult;
21706 }
21707
21708
21709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21710   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21711
21712   arg1 = (Dali::TypeRegistry *)jarg1;
21713   {
21714     try {
21715       delete arg1;
21716     } catch (std::out_of_range& e) {
21717       {
21718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21719       };
21720     } catch (std::exception& e) {
21721       {
21722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21723       };
21724     } catch (Dali::DaliException e) {
21725       {
21726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21727       };
21728     } catch (...) {
21729       {
21730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21731       };
21732     }
21733   }
21734
21735 }
21736
21737
21738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21739   void * jresult ;
21740   Dali::TypeRegistry *arg1 = 0 ;
21741   Dali::TypeRegistry *result = 0 ;
21742
21743   arg1 = (Dali::TypeRegistry *)jarg1;
21744   if (!arg1) {
21745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21746     return 0;
21747   }
21748   {
21749     try {
21750       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21751     } catch (std::out_of_range& e) {
21752       {
21753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21754       };
21755     } catch (std::exception& e) {
21756       {
21757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21758       };
21759     } catch (Dali::DaliException e) {
21760       {
21761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21762       };
21763     } catch (...) {
21764       {
21765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21766       };
21767     }
21768   }
21769
21770   jresult = (void *)result;
21771   return jresult;
21772 }
21773
21774
21775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21776   void * jresult ;
21777   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21778   Dali::TypeRegistry *arg2 = 0 ;
21779   Dali::TypeRegistry *result = 0 ;
21780
21781   arg1 = (Dali::TypeRegistry *)jarg1;
21782   arg2 = (Dali::TypeRegistry *)jarg2;
21783   if (!arg2) {
21784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21785     return 0;
21786   }
21787   {
21788     try {
21789       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21790     } catch (std::out_of_range& e) {
21791       {
21792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21793       };
21794     } catch (std::exception& e) {
21795       {
21796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21797       };
21798     } catch (Dali::DaliException e) {
21799       {
21800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21801       };
21802     } catch (...) {
21803       {
21804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21805       };
21806     }
21807   }
21808
21809   jresult = (void *)result;
21810   return jresult;
21811 }
21812
21813
21814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21815   void * jresult ;
21816   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21817   std::string *arg2 = 0 ;
21818   Dali::TypeInfo result;
21819
21820   arg1 = (Dali::TypeRegistry *)jarg1;
21821   if (!jarg2) {
21822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21823     return 0;
21824   }
21825   std::string arg2_str(jarg2);
21826   arg2 = &arg2_str;
21827   {
21828     try {
21829       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21830     } catch (std::out_of_range& e) {
21831       {
21832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21833       };
21834     } catch (std::exception& e) {
21835       {
21836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21837       };
21838     } catch (Dali::DaliException e) {
21839       {
21840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21841       };
21842     } catch (...) {
21843       {
21844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21845       };
21846     }
21847   }
21848
21849   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21850
21851   //argout typemap for const std::string&
21852
21853   return jresult;
21854 }
21855
21856
21857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21858   void * jresult ;
21859   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21860   std::type_info *arg2 = 0 ;
21861   Dali::TypeInfo result;
21862
21863   arg1 = (Dali::TypeRegistry *)jarg1;
21864   arg2 = (std::type_info *)jarg2;
21865   if (!arg2) {
21866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21867     return 0;
21868   }
21869   {
21870     try {
21871       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21872     } catch (std::out_of_range& e) {
21873       {
21874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21875       };
21876     } catch (std::exception& e) {
21877       {
21878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21879       };
21880     } catch (Dali::DaliException e) {
21881       {
21882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21883       };
21884     } catch (...) {
21885       {
21886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21887       };
21888     }
21889   }
21890
21891   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21892   return jresult;
21893 }
21894
21895
21896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21897   unsigned long jresult ;
21898   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21899   size_t result;
21900
21901   arg1 = (Dali::TypeRegistry *)jarg1;
21902   {
21903     try {
21904       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21905     } catch (std::out_of_range& e) {
21906       {
21907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21908       };
21909     } catch (std::exception& e) {
21910       {
21911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21912       };
21913     } catch (Dali::DaliException e) {
21914       {
21915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21916       };
21917     } catch (...) {
21918       {
21919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21920       };
21921     }
21922   }
21923
21924   jresult = (unsigned long)result;
21925   return jresult;
21926 }
21927
21928
21929 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21930   char * jresult ;
21931   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21932   size_t arg2 ;
21933   std::string result;
21934
21935   arg1 = (Dali::TypeRegistry *)jarg1;
21936   arg2 = (size_t)jarg2;
21937   {
21938     try {
21939       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21940     } catch (std::out_of_range& e) {
21941       {
21942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21943       };
21944     } catch (std::exception& e) {
21945       {
21946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21947       };
21948     } catch (Dali::DaliException e) {
21949       {
21950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21951       };
21952     } catch (...) {
21953       {
21954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21955       };
21956     }
21957   }
21958
21959   jresult = SWIG_csharp_string_callback((&result)->c_str());
21960   return jresult;
21961 }
21962
21963
21964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21965   void * jresult ;
21966   std::type_info *arg1 = 0 ;
21967   std::type_info *arg2 = 0 ;
21968   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21969   Dali::TypeRegistration *result = 0 ;
21970
21971   arg1 = (std::type_info *)jarg1;
21972   if (!arg1) {
21973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21974     return 0;
21975   }
21976   arg2 = (std::type_info *)jarg2;
21977   if (!arg2) {
21978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21979     return 0;
21980   }
21981   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21982   {
21983     try {
21984       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21985     } catch (std::out_of_range& e) {
21986       {
21987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21988       };
21989     } catch (std::exception& e) {
21990       {
21991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21992       };
21993     } catch (Dali::DaliException e) {
21994       {
21995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21996       };
21997     } catch (...) {
21998       {
21999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22000       };
22001     }
22002   }
22003
22004   jresult = (void *)result;
22005   return jresult;
22006 }
22007
22008
22009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22010   void * jresult ;
22011   std::type_info *arg1 = 0 ;
22012   std::type_info *arg2 = 0 ;
22013   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22014   bool arg4 ;
22015   Dali::TypeRegistration *result = 0 ;
22016
22017   arg1 = (std::type_info *)jarg1;
22018   if (!arg1) {
22019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22020     return 0;
22021   }
22022   arg2 = (std::type_info *)jarg2;
22023   if (!arg2) {
22024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22025     return 0;
22026   }
22027   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22028   arg4 = jarg4 ? true : false;
22029   {
22030     try {
22031       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22032     } catch (std::out_of_range& e) {
22033       {
22034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22035       };
22036     } catch (std::exception& e) {
22037       {
22038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22039       };
22040     } catch (Dali::DaliException e) {
22041       {
22042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22043       };
22044     } catch (...) {
22045       {
22046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22047       };
22048     }
22049   }
22050
22051   jresult = (void *)result;
22052   return jresult;
22053 }
22054
22055
22056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22057   void * jresult ;
22058   std::string *arg1 = 0 ;
22059   std::type_info *arg2 = 0 ;
22060   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22061   Dali::TypeRegistration *result = 0 ;
22062
22063   if (!jarg1) {
22064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22065     return 0;
22066   }
22067   std::string arg1_str(jarg1);
22068   arg1 = &arg1_str;
22069   arg2 = (std::type_info *)jarg2;
22070   if (!arg2) {
22071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22072     return 0;
22073   }
22074   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22075   {
22076     try {
22077       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22078     } catch (std::out_of_range& e) {
22079       {
22080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22081       };
22082     } catch (std::exception& e) {
22083       {
22084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22085       };
22086     } catch (Dali::DaliException e) {
22087       {
22088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22089       };
22090     } catch (...) {
22091       {
22092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22093       };
22094     }
22095   }
22096
22097   jresult = (void *)result;
22098
22099   //argout typemap for const std::string&
22100
22101   return jresult;
22102 }
22103
22104
22105 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22106   char * jresult ;
22107   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22108   std::string result;
22109
22110   arg1 = (Dali::TypeRegistration *)jarg1;
22111   {
22112     try {
22113       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22114     } catch (std::out_of_range& e) {
22115       {
22116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22117       };
22118     } catch (std::exception& e) {
22119       {
22120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22121       };
22122     } catch (Dali::DaliException e) {
22123       {
22124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22125       };
22126     } catch (...) {
22127       {
22128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22129       };
22130     }
22131   }
22132
22133   jresult = SWIG_csharp_string_callback((&result)->c_str());
22134   return jresult;
22135 }
22136
22137
22138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22139   std::string *arg1 = 0 ;
22140   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22141
22142   if (!jarg1) {
22143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22144     return ;
22145   }
22146   std::string arg1_str(jarg1);
22147   arg1 = &arg1_str;
22148   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22149   {
22150     try {
22151       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22152     } catch (std::out_of_range& e) {
22153       {
22154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22155       };
22156     } catch (std::exception& e) {
22157       {
22158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22159       };
22160     } catch (Dali::DaliException e) {
22161       {
22162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22163       };
22164     } catch (...) {
22165       {
22166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22167       };
22168     }
22169   }
22170
22171
22172   //argout typemap for const std::string&
22173
22174 }
22175
22176
22177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22178   std::string *arg1 = 0 ;
22179   std::string *arg2 = 0 ;
22180   int arg3 ;
22181   Dali::Property::Type arg4 ;
22182   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22183   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22184
22185   if (!jarg1) {
22186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22187     return ;
22188   }
22189   std::string arg1_str(jarg1);
22190   arg1 = &arg1_str;
22191   if (!jarg2) {
22192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22193     return ;
22194   }
22195   std::string arg2_str(jarg2);
22196   arg2 = &arg2_str;
22197   arg3 = (int)jarg3;
22198   arg4 = (Dali::Property::Type)jarg4;
22199   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22200   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22201   {
22202     try {
22203       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22204     } catch (std::out_of_range& e) {
22205       {
22206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22207       };
22208     } catch (std::exception& e) {
22209       {
22210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22211       };
22212     } catch (Dali::DaliException e) {
22213       {
22214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22215       };
22216     } catch (...) {
22217       {
22218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22219       };
22220     }
22221   }
22222
22223
22224   //argout typemap for const std::string&
22225
22226
22227   //argout typemap for const std::string&
22228
22229 }
22230
22231
22232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22233   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22234
22235   arg1 = (Dali::TypeRegistration *)jarg1;
22236   {
22237     try {
22238       delete arg1;
22239     } catch (std::out_of_range& e) {
22240       {
22241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22242       };
22243     } catch (std::exception& e) {
22244       {
22245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22246       };
22247     } catch (Dali::DaliException e) {
22248       {
22249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22250       };
22251     } catch (...) {
22252       {
22253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22254       };
22255     }
22256   }
22257
22258 }
22259
22260
22261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22262   void * jresult ;
22263   Dali::TypeRegistration *arg1 = 0 ;
22264   std::string *arg2 = 0 ;
22265   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22266   Dali::SignalConnectorType *result = 0 ;
22267
22268   arg1 = (Dali::TypeRegistration *)jarg1;
22269   if (!arg1) {
22270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22271     return 0;
22272   }
22273   if (!jarg2) {
22274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22275     return 0;
22276   }
22277   std::string arg2_str(jarg2);
22278   arg2 = &arg2_str;
22279   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22280   {
22281     try {
22282       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22283     } catch (std::out_of_range& e) {
22284       {
22285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22286       };
22287     } catch (std::exception& e) {
22288       {
22289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22290       };
22291     } catch (Dali::DaliException e) {
22292       {
22293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22294       };
22295     } catch (...) {
22296       {
22297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22298       };
22299     }
22300   }
22301
22302   jresult = (void *)result;
22303
22304   //argout typemap for const std::string&
22305
22306   return jresult;
22307 }
22308
22309
22310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22311   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22312
22313   arg1 = (Dali::SignalConnectorType *)jarg1;
22314   {
22315     try {
22316       delete arg1;
22317     } catch (std::out_of_range& e) {
22318       {
22319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22320       };
22321     } catch (std::exception& e) {
22322       {
22323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22324       };
22325     } catch (Dali::DaliException e) {
22326       {
22327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22328       };
22329     } catch (...) {
22330       {
22331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22332       };
22333     }
22334   }
22335
22336 }
22337
22338
22339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22340   void * jresult ;
22341   Dali::TypeRegistration *arg1 = 0 ;
22342   std::string *arg2 = 0 ;
22343   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22344   Dali::TypeAction *result = 0 ;
22345
22346   arg1 = (Dali::TypeRegistration *)jarg1;
22347   if (!arg1) {
22348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22349     return 0;
22350   }
22351   if (!jarg2) {
22352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22353     return 0;
22354   }
22355   std::string arg2_str(jarg2);
22356   arg2 = &arg2_str;
22357   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22358   {
22359     try {
22360       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22361     } catch (std::out_of_range& e) {
22362       {
22363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22364       };
22365     } catch (std::exception& e) {
22366       {
22367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22368       };
22369     } catch (Dali::DaliException e) {
22370       {
22371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22372       };
22373     } catch (...) {
22374       {
22375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22376       };
22377     }
22378   }
22379
22380   jresult = (void *)result;
22381
22382   //argout typemap for const std::string&
22383
22384   return jresult;
22385 }
22386
22387
22388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22389   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22390
22391   arg1 = (Dali::TypeAction *)jarg1;
22392   {
22393     try {
22394       delete arg1;
22395     } catch (std::out_of_range& e) {
22396       {
22397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22398       };
22399     } catch (std::exception& e) {
22400       {
22401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22402       };
22403     } catch (Dali::DaliException e) {
22404       {
22405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22406       };
22407     } catch (...) {
22408       {
22409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22410       };
22411     }
22412   }
22413
22414 }
22415
22416
22417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22418   void * jresult ;
22419   Dali::TypeRegistration *arg1 = 0 ;
22420   std::string *arg2 = 0 ;
22421   Dali::Property::Index arg3 ;
22422   Dali::Property::Type arg4 ;
22423   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22424   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22425   Dali::PropertyRegistration *result = 0 ;
22426
22427   arg1 = (Dali::TypeRegistration *)jarg1;
22428   if (!arg1) {
22429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22430     return 0;
22431   }
22432   if (!jarg2) {
22433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22434     return 0;
22435   }
22436   std::string arg2_str(jarg2);
22437   arg2 = &arg2_str;
22438   arg3 = (Dali::Property::Index)jarg3;
22439   arg4 = (Dali::Property::Type)jarg4;
22440   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22441   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22442   {
22443     try {
22444       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22445     } catch (std::out_of_range& e) {
22446       {
22447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22448       };
22449     } catch (std::exception& e) {
22450       {
22451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22452       };
22453     } catch (Dali::DaliException e) {
22454       {
22455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22456       };
22457     } catch (...) {
22458       {
22459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22460       };
22461     }
22462   }
22463
22464   jresult = (void *)result;
22465
22466   //argout typemap for const std::string&
22467
22468   return jresult;
22469 }
22470
22471
22472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22473   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22474
22475   arg1 = (Dali::PropertyRegistration *)jarg1;
22476   {
22477     try {
22478       delete arg1;
22479     } catch (std::out_of_range& e) {
22480       {
22481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22482       };
22483     } catch (std::exception& e) {
22484       {
22485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22486       };
22487     } catch (Dali::DaliException e) {
22488       {
22489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22490       };
22491     } catch (...) {
22492       {
22493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22494       };
22495     }
22496   }
22497
22498 }
22499
22500
22501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22502   void * jresult ;
22503   Dali::TypeRegistration *arg1 = 0 ;
22504   std::string *arg2 = 0 ;
22505   Dali::Property::Index arg3 ;
22506   Dali::Property::Type arg4 ;
22507   Dali::AnimatablePropertyRegistration *result = 0 ;
22508
22509   arg1 = (Dali::TypeRegistration *)jarg1;
22510   if (!arg1) {
22511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22512     return 0;
22513   }
22514   if (!jarg2) {
22515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22516     return 0;
22517   }
22518   std::string arg2_str(jarg2);
22519   arg2 = &arg2_str;
22520   arg3 = (Dali::Property::Index)jarg3;
22521   arg4 = (Dali::Property::Type)jarg4;
22522   {
22523     try {
22524       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22525     } catch (std::out_of_range& e) {
22526       {
22527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22528       };
22529     } catch (std::exception& e) {
22530       {
22531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22532       };
22533     } catch (Dali::DaliException e) {
22534       {
22535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22536       };
22537     } catch (...) {
22538       {
22539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22540       };
22541     }
22542   }
22543
22544   jresult = (void *)result;
22545
22546   //argout typemap for const std::string&
22547
22548   return jresult;
22549 }
22550
22551
22552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22553   void * jresult ;
22554   Dali::TypeRegistration *arg1 = 0 ;
22555   std::string *arg2 = 0 ;
22556   Dali::Property::Index arg3 ;
22557   Dali::Property::Value *arg4 = 0 ;
22558   Dali::AnimatablePropertyRegistration *result = 0 ;
22559
22560   arg1 = (Dali::TypeRegistration *)jarg1;
22561   if (!arg1) {
22562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22563     return 0;
22564   }
22565   if (!jarg2) {
22566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22567     return 0;
22568   }
22569   std::string arg2_str(jarg2);
22570   arg2 = &arg2_str;
22571   arg3 = (Dali::Property::Index)jarg3;
22572   arg4 = (Dali::Property::Value *)jarg4;
22573   if (!arg4) {
22574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22575     return 0;
22576   }
22577   {
22578     try {
22579       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22580     } catch (std::out_of_range& e) {
22581       {
22582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22583       };
22584     } catch (std::exception& e) {
22585       {
22586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22587       };
22588     } catch (Dali::DaliException e) {
22589       {
22590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22591       };
22592     } catch (...) {
22593       {
22594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22595       };
22596     }
22597   }
22598
22599   jresult = (void *)result;
22600
22601   //argout typemap for const std::string&
22602
22603   return jresult;
22604 }
22605
22606
22607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22608   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22609
22610   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22611   {
22612     try {
22613       delete arg1;
22614     } catch (std::out_of_range& e) {
22615       {
22616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22617       };
22618     } catch (std::exception& e) {
22619       {
22620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22621       };
22622     } catch (Dali::DaliException e) {
22623       {
22624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22625       };
22626     } catch (...) {
22627       {
22628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22629       };
22630     }
22631   }
22632
22633 }
22634
22635
22636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22637   void * jresult ;
22638   Dali::TypeRegistration *arg1 = 0 ;
22639   std::string *arg2 = 0 ;
22640   Dali::Property::Index arg3 ;
22641   Dali::Property::Index arg4 ;
22642   unsigned int arg5 ;
22643   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22644
22645   arg1 = (Dali::TypeRegistration *)jarg1;
22646   if (!arg1) {
22647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22648     return 0;
22649   }
22650   if (!jarg2) {
22651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22652     return 0;
22653   }
22654   std::string arg2_str(jarg2);
22655   arg2 = &arg2_str;
22656   arg3 = (Dali::Property::Index)jarg3;
22657   arg4 = (Dali::Property::Index)jarg4;
22658   arg5 = (unsigned int)jarg5;
22659   {
22660     try {
22661       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22662     } catch (std::out_of_range& e) {
22663       {
22664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22665       };
22666     } catch (std::exception& e) {
22667       {
22668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22669       };
22670     } catch (Dali::DaliException e) {
22671       {
22672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22673       };
22674     } catch (...) {
22675       {
22676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22677       };
22678     }
22679   }
22680
22681   jresult = (void *)result;
22682
22683   //argout typemap for const std::string&
22684
22685   return jresult;
22686 }
22687
22688
22689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22690   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22691
22692   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22693   {
22694     try {
22695       delete arg1;
22696     } catch (std::out_of_range& e) {
22697       {
22698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22699       };
22700     } catch (std::exception& e) {
22701       {
22702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22703       };
22704     } catch (Dali::DaliException e) {
22705       {
22706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22707       };
22708     } catch (...) {
22709       {
22710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22711       };
22712     }
22713   }
22714
22715 }
22716
22717
22718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22719   void * jresult ;
22720   Dali::TypeRegistration *arg1 = 0 ;
22721   std::string *arg2 = 0 ;
22722   Dali::Property::Index arg3 ;
22723   Dali::Property::Type arg4 ;
22724   Dali::ChildPropertyRegistration *result = 0 ;
22725
22726   arg1 = (Dali::TypeRegistration *)jarg1;
22727   if (!arg1) {
22728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22729     return 0;
22730   }
22731   if (!jarg2) {
22732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22733     return 0;
22734   }
22735   std::string arg2_str(jarg2);
22736   arg2 = &arg2_str;
22737   arg3 = (Dali::Property::Index)jarg3;
22738   arg4 = (Dali::Property::Type)jarg4;
22739   {
22740     try {
22741       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22742     } catch (std::out_of_range& e) {
22743       {
22744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22745       };
22746     } catch (std::exception& e) {
22747       {
22748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22749       };
22750     } catch (Dali::DaliException e) {
22751       {
22752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22753       };
22754     } catch (...) {
22755       {
22756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22757       };
22758     }
22759   }
22760
22761   jresult = (void *)result;
22762
22763   //argout typemap for const std::string&
22764
22765   return jresult;
22766 }
22767
22768
22769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22770   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22771
22772   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22773   {
22774     try {
22775       delete arg1;
22776     } catch (std::out_of_range& e) {
22777       {
22778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22779       };
22780     } catch (std::exception& e) {
22781       {
22782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22783       };
22784     } catch (Dali::DaliException e) {
22785       {
22786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22787       };
22788     } catch (...) {
22789       {
22790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22791       };
22792     }
22793   }
22794
22795 }
22796
22797
22798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22799   unsigned int jresult ;
22800   std::string *arg1 = 0 ;
22801   std::type_info *arg2 = 0 ;
22802   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22803   bool result;
22804
22805   if (!jarg1) {
22806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22807     return 0;
22808   }
22809   std::string arg1_str(jarg1);
22810   arg1 = &arg1_str;
22811   arg2 = (std::type_info *)jarg2;
22812   if (!arg2) {
22813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22814     return 0;
22815   }
22816   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22817   {
22818     try {
22819       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22820     } catch (std::out_of_range& e) {
22821       {
22822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22823       };
22824     } catch (std::exception& e) {
22825       {
22826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22827       };
22828     } catch (Dali::DaliException e) {
22829       {
22830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22831       };
22832     } catch (...) {
22833       {
22834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22835       };
22836     }
22837   }
22838
22839   jresult = result;
22840
22841   //argout typemap for const std::string&
22842
22843   return jresult;
22844 }
22845
22846
22847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22848   unsigned int jresult ;
22849   std::string *arg1 = 0 ;
22850   std::string *arg2 = 0 ;
22851   Dali::Property::Index arg3 ;
22852   Dali::Property::Type arg4 ;
22853   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22854   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22855   bool result;
22856
22857   if (!jarg1) {
22858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22859     return 0;
22860   }
22861   std::string arg1_str(jarg1);
22862   arg1 = &arg1_str;
22863   if (!jarg2) {
22864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22865     return 0;
22866   }
22867   std::string arg2_str(jarg2);
22868   arg2 = &arg2_str;
22869   arg3 = (Dali::Property::Index)jarg3;
22870   arg4 = (Dali::Property::Type)jarg4;
22871   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22872   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22873   {
22874     try {
22875       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22876     } catch (std::out_of_range& e) {
22877       {
22878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22879       };
22880     } catch (std::exception& e) {
22881       {
22882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22883       };
22884     } catch (Dali::DaliException e) {
22885       {
22886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22887       };
22888     } catch (...) {
22889       {
22890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22891       };
22892     }
22893   }
22894
22895   jresult = result;
22896
22897   //argout typemap for const std::string&
22898
22899
22900   //argout typemap for const std::string&
22901
22902   return jresult;
22903 }
22904
22905
22906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22907   float jresult ;
22908   float result;
22909
22910   result = (float)(float)Dali::ParentOrigin::TOP;
22911   jresult = result;
22912   return jresult;
22913 }
22914
22915
22916 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22917   float jresult ;
22918   float result;
22919
22920   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22921   jresult = result;
22922   return jresult;
22923 }
22924
22925
22926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22927   float jresult ;
22928   float result;
22929
22930   result = (float)(float)Dali::ParentOrigin::LEFT;
22931   jresult = result;
22932   return jresult;
22933 }
22934
22935
22936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22937   float jresult ;
22938   float result;
22939
22940   result = (float)(float)Dali::ParentOrigin::RIGHT;
22941   jresult = result;
22942   return jresult;
22943 }
22944
22945
22946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22947   float jresult ;
22948   float result;
22949
22950   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22951   jresult = result;
22952   return jresult;
22953 }
22954
22955
22956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22957   void * jresult ;
22958   Dali::Vector3 *result = 0 ;
22959
22960   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22961   jresult = (void *)result;
22962   return jresult;
22963 }
22964
22965
22966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22967   void * jresult ;
22968   Dali::Vector3 *result = 0 ;
22969
22970   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22971   jresult = (void *)result;
22972   return jresult;
22973 }
22974
22975
22976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22977   void * jresult ;
22978   Dali::Vector3 *result = 0 ;
22979
22980   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22981   jresult = (void *)result;
22982   return jresult;
22983 }
22984
22985
22986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22987   void * jresult ;
22988   Dali::Vector3 *result = 0 ;
22989
22990   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22991   jresult = (void *)result;
22992   return jresult;
22993 }
22994
22995
22996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
22997   void * jresult ;
22998   Dali::Vector3 *result = 0 ;
22999
23000   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23001   jresult = (void *)result;
23002   return jresult;
23003 }
23004
23005
23006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23007   void * jresult ;
23008   Dali::Vector3 *result = 0 ;
23009
23010   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23011   jresult = (void *)result;
23012   return jresult;
23013 }
23014
23015
23016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23017   void * jresult ;
23018   Dali::Vector3 *result = 0 ;
23019
23020   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23021   jresult = (void *)result;
23022   return jresult;
23023 }
23024
23025
23026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23027   void * jresult ;
23028   Dali::Vector3 *result = 0 ;
23029
23030   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23031   jresult = (void *)result;
23032   return jresult;
23033 }
23034
23035
23036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23037   void * jresult ;
23038   Dali::Vector3 *result = 0 ;
23039
23040   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23041   jresult = (void *)result;
23042   return jresult;
23043 }
23044
23045
23046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23047   float jresult ;
23048   float result;
23049
23050   result = (float)(float)Dali::AnchorPoint::TOP;
23051   jresult = result;
23052   return jresult;
23053 }
23054
23055
23056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23057   float jresult ;
23058   float result;
23059
23060   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23061   jresult = result;
23062   return jresult;
23063 }
23064
23065
23066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23067   float jresult ;
23068   float result;
23069
23070   result = (float)(float)Dali::AnchorPoint::LEFT;
23071   jresult = result;
23072   return jresult;
23073 }
23074
23075
23076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23077   float jresult ;
23078   float result;
23079
23080   result = (float)(float)Dali::AnchorPoint::RIGHT;
23081   jresult = result;
23082   return jresult;
23083 }
23084
23085
23086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23087   float jresult ;
23088   float result;
23089
23090   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23091   jresult = result;
23092   return jresult;
23093 }
23094
23095
23096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23097   void * jresult ;
23098   Dali::Vector3 *result = 0 ;
23099
23100   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23101   jresult = (void *)result;
23102   return jresult;
23103 }
23104
23105
23106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23107   void * jresult ;
23108   Dali::Vector3 *result = 0 ;
23109
23110   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23111   jresult = (void *)result;
23112   return jresult;
23113 }
23114
23115
23116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23117   void * jresult ;
23118   Dali::Vector3 *result = 0 ;
23119
23120   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23121   jresult = (void *)result;
23122   return jresult;
23123 }
23124
23125
23126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23127   void * jresult ;
23128   Dali::Vector3 *result = 0 ;
23129
23130   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23131   jresult = (void *)result;
23132   return jresult;
23133 }
23134
23135
23136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23137   void * jresult ;
23138   Dali::Vector3 *result = 0 ;
23139
23140   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23141   jresult = (void *)result;
23142   return jresult;
23143 }
23144
23145
23146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23147   void * jresult ;
23148   Dali::Vector3 *result = 0 ;
23149
23150   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23151   jresult = (void *)result;
23152   return jresult;
23153 }
23154
23155
23156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23157   void * jresult ;
23158   Dali::Vector3 *result = 0 ;
23159
23160   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23161   jresult = (void *)result;
23162   return jresult;
23163 }
23164
23165
23166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23167   void * jresult ;
23168   Dali::Vector3 *result = 0 ;
23169
23170   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23171   jresult = (void *)result;
23172   return jresult;
23173 }
23174
23175
23176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23177   void * jresult ;
23178   Dali::Vector3 *result = 0 ;
23179
23180   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23181   jresult = (void *)result;
23182   return jresult;
23183 }
23184
23185
23186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23187   void * jresult ;
23188   Dali::Vector4 *result = 0 ;
23189
23190   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23191   jresult = (void *)result;
23192   return jresult;
23193 }
23194
23195
23196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23197   void * jresult ;
23198   Dali::Vector4 *result = 0 ;
23199
23200   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23201   jresult = (void *)result;
23202   return jresult;
23203 }
23204
23205
23206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23207   void * jresult ;
23208   Dali::Vector4 *result = 0 ;
23209
23210   result = (Dali::Vector4 *)&Dali::Color::RED;
23211   jresult = (void *)result;
23212   return jresult;
23213 }
23214
23215
23216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23217   void * jresult ;
23218   Dali::Vector4 *result = 0 ;
23219
23220   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23221   jresult = (void *)result;
23222   return jresult;
23223 }
23224
23225
23226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23227   void * jresult ;
23228   Dali::Vector4 *result = 0 ;
23229
23230   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23231   jresult = (void *)result;
23232   return jresult;
23233 }
23234
23235
23236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23237   void * jresult ;
23238   Dali::Vector4 *result = 0 ;
23239
23240   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23241   jresult = (void *)result;
23242   return jresult;
23243 }
23244
23245
23246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23247   void * jresult ;
23248   Dali::Vector4 *result = 0 ;
23249
23250   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23251   jresult = (void *)result;
23252   return jresult;
23253 }
23254
23255
23256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23257   void * jresult ;
23258   Dali::Vector4 *result = 0 ;
23259
23260   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23261   jresult = (void *)result;
23262   return jresult;
23263 }
23264
23265
23266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23267   void * jresult ;
23268   Dali::Vector4 *result = 0 ;
23269
23270   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23271   jresult = (void *)result;
23272   return jresult;
23273 }
23274
23275
23276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23277   float jresult ;
23278   float result;
23279
23280   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23281   jresult = result;
23282   return jresult;
23283 }
23284
23285
23286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23287   float jresult ;
23288   float result;
23289
23290   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23291   jresult = result;
23292   return jresult;
23293 }
23294
23295
23296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23297   float jresult ;
23298   float result;
23299
23300   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23301   jresult = result;
23302   return jresult;
23303 }
23304
23305
23306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23307   float jresult ;
23308   float result;
23309
23310   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23311   jresult = result;
23312   return jresult;
23313 }
23314
23315
23316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23317   float jresult ;
23318   float result;
23319
23320   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23321   jresult = result;
23322   return jresult;
23323 }
23324
23325
23326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23327   float jresult ;
23328   float result;
23329
23330   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23331   jresult = result;
23332   return jresult;
23333 }
23334
23335
23336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23337   float jresult ;
23338   float result;
23339
23340   result = (float)(float)Dali::Math::PI;
23341   jresult = result;
23342   return jresult;
23343 }
23344
23345
23346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23347   float jresult ;
23348   float result;
23349
23350   result = (float)(float)Dali::Math::PI_2;
23351   jresult = result;
23352   return jresult;
23353 }
23354
23355
23356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23357   float jresult ;
23358   float result;
23359
23360   result = (float)(float)Dali::Math::PI_4;
23361   jresult = result;
23362   return jresult;
23363 }
23364
23365
23366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23367   float jresult ;
23368   float result;
23369
23370   result = (float)(float)Dali::Math::PI_OVER_180;
23371   jresult = result;
23372   return jresult;
23373 }
23374
23375
23376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23377   float jresult ;
23378   float result;
23379
23380   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23381   jresult = result;
23382   return jresult;
23383 }
23384
23385
23386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23387   int jresult ;
23388   Dali::ResizePolicy::Type result;
23389
23390   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23391   jresult = (int)result;
23392   return jresult;
23393 }
23394
23395
23396 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23397   unsigned long jresult ;
23398   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23399   Dali::VectorBase::SizeType result;
23400
23401   arg1 = (Dali::VectorBase *)jarg1;
23402   {
23403     try {
23404       result = ((Dali::VectorBase const *)arg1)->Count();
23405     } catch (std::out_of_range& e) {
23406       {
23407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23408       };
23409     } catch (std::exception& e) {
23410       {
23411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23412       };
23413     } catch (Dali::DaliException e) {
23414       {
23415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23416       };
23417     } catch (...) {
23418       {
23419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23420       };
23421     }
23422   }
23423
23424   jresult = (unsigned long)result;
23425   return jresult;
23426 }
23427
23428
23429 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23430   unsigned long jresult ;
23431   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23432   Dali::VectorBase::SizeType result;
23433
23434   arg1 = (Dali::VectorBase *)jarg1;
23435   {
23436     try {
23437       result = ((Dali::VectorBase const *)arg1)->Size();
23438     } catch (std::out_of_range& e) {
23439       {
23440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23441       };
23442     } catch (std::exception& e) {
23443       {
23444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23445       };
23446     } catch (Dali::DaliException e) {
23447       {
23448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23449       };
23450     } catch (...) {
23451       {
23452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23453       };
23454     }
23455   }
23456
23457   jresult = (unsigned long)result;
23458   return jresult;
23459 }
23460
23461
23462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23463   unsigned int jresult ;
23464   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23465   bool result;
23466
23467   arg1 = (Dali::VectorBase *)jarg1;
23468   {
23469     try {
23470       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23471     } catch (std::out_of_range& e) {
23472       {
23473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23474       };
23475     } catch (std::exception& e) {
23476       {
23477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23478       };
23479     } catch (Dali::DaliException e) {
23480       {
23481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23482       };
23483     } catch (...) {
23484       {
23485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23486       };
23487     }
23488   }
23489
23490   jresult = result;
23491   return jresult;
23492 }
23493
23494
23495 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23496   unsigned long jresult ;
23497   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23498   Dali::VectorBase::SizeType result;
23499
23500   arg1 = (Dali::VectorBase *)jarg1;
23501   {
23502     try {
23503       result = ((Dali::VectorBase const *)arg1)->Capacity();
23504     } catch (std::out_of_range& e) {
23505       {
23506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23507       };
23508     } catch (std::exception& e) {
23509       {
23510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23511       };
23512     } catch (Dali::DaliException e) {
23513       {
23514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23515       };
23516     } catch (...) {
23517       {
23518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23519       };
23520     }
23521   }
23522
23523   jresult = (unsigned long)result;
23524   return jresult;
23525 }
23526
23527
23528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23529   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23530
23531   arg1 = (Dali::VectorBase *)jarg1;
23532   {
23533     try {
23534       (arg1)->Release();
23535     } catch (std::out_of_range& e) {
23536       {
23537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23538       };
23539     } catch (std::exception& e) {
23540       {
23541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23542       };
23543     } catch (Dali::DaliException e) {
23544       {
23545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23546       };
23547     } catch (...) {
23548       {
23549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23550       };
23551     }
23552   }
23553
23554 }
23555
23556
23557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23558   void * jresult ;
23559   Dali::Image *result = 0 ;
23560
23561   {
23562     try {
23563       result = (Dali::Image *)new Dali::Image();
23564     } catch (std::out_of_range& e) {
23565       {
23566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23567       };
23568     } catch (std::exception& e) {
23569       {
23570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23571       };
23572     } catch (Dali::DaliException e) {
23573       {
23574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23575       };
23576     } catch (...) {
23577       {
23578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23579       };
23580     }
23581   }
23582
23583   jresult = (void *)result;
23584   return jresult;
23585 }
23586
23587
23588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23589   Dali::Image *arg1 = (Dali::Image *) 0 ;
23590
23591   arg1 = (Dali::Image *)jarg1;
23592   {
23593     try {
23594       delete arg1;
23595     } catch (std::out_of_range& e) {
23596       {
23597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23598       };
23599     } catch (std::exception& e) {
23600       {
23601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23602       };
23603     } catch (Dali::DaliException e) {
23604       {
23605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23606       };
23607     } catch (...) {
23608       {
23609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23610       };
23611     }
23612   }
23613
23614 }
23615
23616
23617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23618   void * jresult ;
23619   Dali::Image *arg1 = 0 ;
23620   Dali::Image *result = 0 ;
23621
23622   arg1 = (Dali::Image *)jarg1;
23623   if (!arg1) {
23624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23625     return 0;
23626   }
23627   {
23628     try {
23629       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23630     } catch (std::out_of_range& e) {
23631       {
23632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23633       };
23634     } catch (std::exception& e) {
23635       {
23636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23637       };
23638     } catch (Dali::DaliException e) {
23639       {
23640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23641       };
23642     } catch (...) {
23643       {
23644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23645       };
23646     }
23647   }
23648
23649   jresult = (void *)result;
23650   return jresult;
23651 }
23652
23653
23654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23655   void * jresult ;
23656   Dali::Image *arg1 = (Dali::Image *) 0 ;
23657   Dali::Image *arg2 = 0 ;
23658   Dali::Image *result = 0 ;
23659
23660   arg1 = (Dali::Image *)jarg1;
23661   arg2 = (Dali::Image *)jarg2;
23662   if (!arg2) {
23663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23664     return 0;
23665   }
23666   {
23667     try {
23668       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23669     } catch (std::out_of_range& e) {
23670       {
23671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23672       };
23673     } catch (std::exception& e) {
23674       {
23675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23676       };
23677     } catch (Dali::DaliException e) {
23678       {
23679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23680       };
23681     } catch (...) {
23682       {
23683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23684       };
23685     }
23686   }
23687
23688   jresult = (void *)result;
23689   return jresult;
23690 }
23691
23692
23693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23694   void * jresult ;
23695   Dali::BaseHandle arg1 ;
23696   Dali::BaseHandle *argp1 ;
23697   Dali::Image result;
23698
23699   argp1 = (Dali::BaseHandle *)jarg1;
23700   if (!argp1) {
23701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23702     return 0;
23703   }
23704   arg1 = *argp1;
23705   {
23706     try {
23707       result = Dali::Image::DownCast(arg1);
23708     } catch (std::out_of_range& e) {
23709       {
23710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23711       };
23712     } catch (std::exception& e) {
23713       {
23714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23715       };
23716     } catch (Dali::DaliException e) {
23717       {
23718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23719       };
23720     } catch (...) {
23721       {
23722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23723       };
23724     }
23725   }
23726
23727   jresult = new Dali::Image((const Dali::Image &)result);
23728   return jresult;
23729 }
23730
23731
23732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23733   unsigned int jresult ;
23734   Dali::Image *arg1 = (Dali::Image *) 0 ;
23735   unsigned int result;
23736
23737   arg1 = (Dali::Image *)jarg1;
23738   {
23739     try {
23740       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23741     } catch (std::out_of_range& e) {
23742       {
23743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23744       };
23745     } catch (std::exception& e) {
23746       {
23747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23748       };
23749     } catch (Dali::DaliException e) {
23750       {
23751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23752       };
23753     } catch (...) {
23754       {
23755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23756       };
23757     }
23758   }
23759
23760   jresult = result;
23761   return jresult;
23762 }
23763
23764
23765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23766   unsigned int jresult ;
23767   Dali::Image *arg1 = (Dali::Image *) 0 ;
23768   unsigned int result;
23769
23770   arg1 = (Dali::Image *)jarg1;
23771   {
23772     try {
23773       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23774     } catch (std::out_of_range& e) {
23775       {
23776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23777       };
23778     } catch (std::exception& e) {
23779       {
23780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23781       };
23782     } catch (Dali::DaliException e) {
23783       {
23784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23785       };
23786     } catch (...) {
23787       {
23788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23789       };
23790     }
23791   }
23792
23793   jresult = result;
23794   return jresult;
23795 }
23796
23797
23798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23799   void * jresult ;
23800   Dali::Image *arg1 = (Dali::Image *) 0 ;
23801   Dali::Image::ImageSignalType *result = 0 ;
23802
23803   arg1 = (Dali::Image *)jarg1;
23804   {
23805     try {
23806       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23807     } catch (std::out_of_range& e) {
23808       {
23809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23810       };
23811     } catch (std::exception& e) {
23812       {
23813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23814       };
23815     } catch (Dali::DaliException e) {
23816       {
23817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23818       };
23819     } catch (...) {
23820       {
23821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23822       };
23823     }
23824   }
23825
23826   jresult = (void *)result;
23827   return jresult;
23828 }
23829
23830
23831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23832   int jresult ;
23833   Dali::Pixel::Format result;
23834
23835   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23836   jresult = (int)result;
23837   return jresult;
23838 }
23839
23840
23841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23842   int jresult ;
23843   Dali::Pixel::Format result;
23844
23845   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23846   jresult = (int)result;
23847   return jresult;
23848 }
23849
23850
23851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23852   unsigned int jresult ;
23853   Dali::Pixel::Format arg1 ;
23854   bool result;
23855
23856   arg1 = (Dali::Pixel::Format)jarg1;
23857   {
23858     try {
23859       result = (bool)Dali::Pixel::HasAlpha(arg1);
23860     } catch (std::out_of_range& e) {
23861       {
23862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23863       };
23864     } catch (std::exception& e) {
23865       {
23866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23867       };
23868     } catch (Dali::DaliException e) {
23869       {
23870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23871       };
23872     } catch (...) {
23873       {
23874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23875       };
23876     }
23877   }
23878
23879   jresult = result;
23880   return jresult;
23881 }
23882
23883
23884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23885   unsigned int jresult ;
23886   Dali::Pixel::Format arg1 ;
23887   unsigned int result;
23888
23889   arg1 = (Dali::Pixel::Format)jarg1;
23890   {
23891     try {
23892       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23893     } catch (std::out_of_range& e) {
23894       {
23895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23896       };
23897     } catch (std::exception& e) {
23898       {
23899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23900       };
23901     } catch (Dali::DaliException e) {
23902       {
23903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23904       };
23905     } catch (...) {
23906       {
23907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23908       };
23909     }
23910   }
23911
23912   jresult = result;
23913   return jresult;
23914 }
23915
23916
23917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23918   Dali::Pixel::Format arg1 ;
23919   int *arg2 = 0 ;
23920   int *arg3 = 0 ;
23921
23922   arg1 = (Dali::Pixel::Format)jarg1;
23923   arg2 = (int *)jarg2;
23924   if (!arg2) {
23925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23926     return ;
23927   }
23928   arg3 = (int *)jarg3;
23929   if (!arg3) {
23930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23931     return ;
23932   }
23933   {
23934     try {
23935       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23936     } catch (std::out_of_range& e) {
23937       {
23938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23939       };
23940     } catch (std::exception& e) {
23941       {
23942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23943       };
23944     } catch (Dali::DaliException e) {
23945       {
23946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23947       };
23948     } catch (...) {
23949       {
23950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23951       };
23952     }
23953   }
23954
23955 }
23956
23957
23958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23959   void * jresult ;
23960   unsigned char *arg1 = (unsigned char *) 0 ;
23961   unsigned int arg2 ;
23962   unsigned int arg3 ;
23963   unsigned int arg4 ;
23964   Dali::Pixel::Format arg5 ;
23965   Dali::PixelData::ReleaseFunction arg6 ;
23966   Dali::PixelData result;
23967
23968   arg1 = jarg1;
23969   arg2 = (unsigned int)jarg2;
23970   arg3 = (unsigned int)jarg3;
23971   arg4 = (unsigned int)jarg4;
23972   arg5 = (Dali::Pixel::Format)jarg5;
23973   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23974   {
23975     try {
23976       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
23977     } catch (std::out_of_range& e) {
23978       {
23979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23980       };
23981     } catch (std::exception& e) {
23982       {
23983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23984       };
23985     } catch (Dali::DaliException e) {
23986       {
23987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23988       };
23989     } catch (...) {
23990       {
23991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23992       };
23993     }
23994   }
23995
23996   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23997
23998
23999   return jresult;
24000 }
24001
24002
24003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24004   void * jresult ;
24005   Dali::PixelData *result = 0 ;
24006
24007   {
24008     try {
24009       result = (Dali::PixelData *)new Dali::PixelData();
24010     } catch (std::out_of_range& e) {
24011       {
24012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24013       };
24014     } catch (std::exception& e) {
24015       {
24016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24017       };
24018     } catch (Dali::DaliException e) {
24019       {
24020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24021       };
24022     } catch (...) {
24023       {
24024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24025       };
24026     }
24027   }
24028
24029   jresult = (void *)result;
24030   return jresult;
24031 }
24032
24033
24034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24035   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24036
24037   arg1 = (Dali::PixelData *)jarg1;
24038   {
24039     try {
24040       delete arg1;
24041     } catch (std::out_of_range& e) {
24042       {
24043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24044       };
24045     } catch (std::exception& e) {
24046       {
24047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24048       };
24049     } catch (Dali::DaliException e) {
24050       {
24051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24052       };
24053     } catch (...) {
24054       {
24055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24056       };
24057     }
24058   }
24059
24060 }
24061
24062
24063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24064   void * jresult ;
24065   Dali::PixelData *arg1 = 0 ;
24066   Dali::PixelData *result = 0 ;
24067
24068   arg1 = (Dali::PixelData *)jarg1;
24069   if (!arg1) {
24070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24071     return 0;
24072   }
24073   {
24074     try {
24075       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24076     } catch (std::out_of_range& e) {
24077       {
24078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24079       };
24080     } catch (std::exception& e) {
24081       {
24082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24083       };
24084     } catch (Dali::DaliException e) {
24085       {
24086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24087       };
24088     } catch (...) {
24089       {
24090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24091       };
24092     }
24093   }
24094
24095   jresult = (void *)result;
24096   return jresult;
24097 }
24098
24099
24100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24101   void * jresult ;
24102   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24103   Dali::PixelData *arg2 = 0 ;
24104   Dali::PixelData *result = 0 ;
24105
24106   arg1 = (Dali::PixelData *)jarg1;
24107   arg2 = (Dali::PixelData *)jarg2;
24108   if (!arg2) {
24109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24110     return 0;
24111   }
24112   {
24113     try {
24114       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24115     } catch (std::out_of_range& e) {
24116       {
24117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24118       };
24119     } catch (std::exception& e) {
24120       {
24121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24122       };
24123     } catch (Dali::DaliException e) {
24124       {
24125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24126       };
24127     } catch (...) {
24128       {
24129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24130       };
24131     }
24132   }
24133
24134   jresult = (void *)result;
24135   return jresult;
24136 }
24137
24138
24139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24140   unsigned int jresult ;
24141   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24142   unsigned int result;
24143
24144   arg1 = (Dali::PixelData *)jarg1;
24145   {
24146     try {
24147       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24148     } catch (std::out_of_range& e) {
24149       {
24150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24151       };
24152     } catch (std::exception& e) {
24153       {
24154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24155       };
24156     } catch (Dali::DaliException e) {
24157       {
24158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24159       };
24160     } catch (...) {
24161       {
24162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24163       };
24164     }
24165   }
24166
24167   jresult = result;
24168   return jresult;
24169 }
24170
24171
24172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24173   unsigned int jresult ;
24174   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24175   unsigned int result;
24176
24177   arg1 = (Dali::PixelData *)jarg1;
24178   {
24179     try {
24180       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24181     } catch (std::out_of_range& e) {
24182       {
24183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24184       };
24185     } catch (std::exception& e) {
24186       {
24187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24188       };
24189     } catch (Dali::DaliException e) {
24190       {
24191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24192       };
24193     } catch (...) {
24194       {
24195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24196       };
24197     }
24198   }
24199
24200   jresult = result;
24201   return jresult;
24202 }
24203
24204
24205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24206   int jresult ;
24207   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24208   Dali::Pixel::Format result;
24209
24210   arg1 = (Dali::PixelData *)jarg1;
24211   {
24212     try {
24213       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24214     } catch (std::out_of_range& e) {
24215       {
24216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24217       };
24218     } catch (std::exception& e) {
24219       {
24220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24221       };
24222     } catch (Dali::DaliException e) {
24223       {
24224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24225       };
24226     } catch (...) {
24227       {
24228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24229       };
24230     }
24231   }
24232
24233   jresult = (int)result;
24234   return jresult;
24235 }
24236
24237
24238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24239   unsigned int jresult ;
24240   unsigned int result;
24241
24242   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24243   jresult = result;
24244   return jresult;
24245 }
24246
24247
24248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24249   unsigned int jresult ;
24250   unsigned int result;
24251
24252   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24253   jresult = result;
24254   return jresult;
24255 }
24256
24257
24258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24259   unsigned int jresult ;
24260   unsigned int result;
24261
24262   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24263   jresult = result;
24264   return jresult;
24265 }
24266
24267
24268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24269   unsigned int jresult ;
24270   unsigned int result;
24271
24272   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24273   jresult = result;
24274   return jresult;
24275 }
24276
24277
24278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24279   unsigned int jresult ;
24280   unsigned int result;
24281
24282   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24283   jresult = result;
24284   return jresult;
24285 }
24286
24287
24288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24289   unsigned int jresult ;
24290   unsigned int result;
24291
24292   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24293   jresult = result;
24294   return jresult;
24295 }
24296
24297
24298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24299   void * jresult ;
24300   Dali::TextureType::Type arg1 ;
24301   Dali::Pixel::Format arg2 ;
24302   unsigned int arg3 ;
24303   unsigned int arg4 ;
24304   Dali::Texture result;
24305
24306   arg1 = (Dali::TextureType::Type)jarg1;
24307   arg2 = (Dali::Pixel::Format)jarg2;
24308   arg3 = (unsigned int)jarg3;
24309   arg4 = (unsigned int)jarg4;
24310   {
24311     try {
24312       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24313     } catch (std::out_of_range& e) {
24314       {
24315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24316       };
24317     } catch (std::exception& e) {
24318       {
24319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24320       };
24321     } catch (Dali::DaliException e) {
24322       {
24323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24324       };
24325     } catch (...) {
24326       {
24327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24328       };
24329     }
24330   }
24331
24332   jresult = new Dali::Texture((const Dali::Texture &)result);
24333   return jresult;
24334 }
24335
24336
24337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24338   void * jresult ;
24339   NativeImageInterface *arg1 = 0 ;
24340   Dali::Texture result;
24341
24342   arg1 = (NativeImageInterface *)jarg1;
24343   if (!arg1) {
24344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24345     return 0;
24346   }
24347   {
24348     try {
24349       result = Dali::Texture::New(*arg1);
24350     } catch (std::out_of_range& e) {
24351       {
24352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24353       };
24354     } catch (std::exception& e) {
24355       {
24356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24357       };
24358     } catch (Dali::DaliException e) {
24359       {
24360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24361       };
24362     } catch (...) {
24363       {
24364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24365       };
24366     }
24367   }
24368
24369   jresult = new Dali::Texture((const Dali::Texture &)result);
24370   return jresult;
24371 }
24372
24373
24374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24375   void * jresult ;
24376   Dali::Texture *result = 0 ;
24377
24378   {
24379     try {
24380       result = (Dali::Texture *)new Dali::Texture();
24381     } catch (std::out_of_range& e) {
24382       {
24383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24384       };
24385     } catch (std::exception& e) {
24386       {
24387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24388       };
24389     } catch (Dali::DaliException e) {
24390       {
24391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24392       };
24393     } catch (...) {
24394       {
24395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24396       };
24397     }
24398   }
24399
24400   jresult = (void *)result;
24401   return jresult;
24402 }
24403
24404
24405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24406   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24407
24408   arg1 = (Dali::Texture *)jarg1;
24409   {
24410     try {
24411       delete arg1;
24412     } catch (std::out_of_range& e) {
24413       {
24414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24415       };
24416     } catch (std::exception& e) {
24417       {
24418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24419       };
24420     } catch (Dali::DaliException e) {
24421       {
24422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24423       };
24424     } catch (...) {
24425       {
24426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24427       };
24428     }
24429   }
24430
24431 }
24432
24433
24434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24435   void * jresult ;
24436   Dali::Texture *arg1 = 0 ;
24437   Dali::Texture *result = 0 ;
24438
24439   arg1 = (Dali::Texture *)jarg1;
24440   if (!arg1) {
24441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24442     return 0;
24443   }
24444   {
24445     try {
24446       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24447     } catch (std::out_of_range& e) {
24448       {
24449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24450       };
24451     } catch (std::exception& e) {
24452       {
24453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24454       };
24455     } catch (Dali::DaliException e) {
24456       {
24457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24458       };
24459     } catch (...) {
24460       {
24461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24462       };
24463     }
24464   }
24465
24466   jresult = (void *)result;
24467   return jresult;
24468 }
24469
24470
24471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24472   void * jresult ;
24473   Dali::BaseHandle arg1 ;
24474   Dali::BaseHandle *argp1 ;
24475   Dali::Texture result;
24476
24477   argp1 = (Dali::BaseHandle *)jarg1;
24478   if (!argp1) {
24479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24480     return 0;
24481   }
24482   arg1 = *argp1;
24483   {
24484     try {
24485       result = Dali::Texture::DownCast(arg1);
24486     } catch (std::out_of_range& e) {
24487       {
24488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24489       };
24490     } catch (std::exception& e) {
24491       {
24492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24493       };
24494     } catch (Dali::DaliException e) {
24495       {
24496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24497       };
24498     } catch (...) {
24499       {
24500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24501       };
24502     }
24503   }
24504
24505   jresult = new Dali::Texture((const Dali::Texture &)result);
24506   return jresult;
24507 }
24508
24509
24510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24511   void * jresult ;
24512   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24513   Dali::Texture *arg2 = 0 ;
24514   Dali::Texture *result = 0 ;
24515
24516   arg1 = (Dali::Texture *)jarg1;
24517   arg2 = (Dali::Texture *)jarg2;
24518   if (!arg2) {
24519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24520     return 0;
24521   }
24522   {
24523     try {
24524       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24525     } catch (std::out_of_range& e) {
24526       {
24527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24528       };
24529     } catch (std::exception& e) {
24530       {
24531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24532       };
24533     } catch (Dali::DaliException e) {
24534       {
24535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24536       };
24537     } catch (...) {
24538       {
24539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24540       };
24541     }
24542   }
24543
24544   jresult = (void *)result;
24545   return jresult;
24546 }
24547
24548
24549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24550   unsigned int jresult ;
24551   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24552   Dali::PixelData arg2 ;
24553   Dali::PixelData *argp2 ;
24554   bool result;
24555
24556   arg1 = (Dali::Texture *)jarg1;
24557   argp2 = (Dali::PixelData *)jarg2;
24558   if (!argp2) {
24559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24560     return 0;
24561   }
24562   arg2 = *argp2;
24563   {
24564     try {
24565       result = (bool)(arg1)->Upload(arg2);
24566     } catch (std::out_of_range& e) {
24567       {
24568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24569       };
24570     } catch (std::exception& e) {
24571       {
24572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24573       };
24574     } catch (Dali::DaliException e) {
24575       {
24576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24577       };
24578     } catch (...) {
24579       {
24580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24581       };
24582     }
24583   }
24584
24585   jresult = result;
24586   return jresult;
24587 }
24588
24589
24590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
24591   unsigned int jresult ;
24592   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24593   Dali::PixelData arg2 ;
24594   unsigned int arg3 ;
24595   unsigned int arg4 ;
24596   unsigned int arg5 ;
24597   unsigned int arg6 ;
24598   unsigned int arg7 ;
24599   unsigned int arg8 ;
24600   Dali::PixelData *argp2 ;
24601   bool result;
24602
24603   arg1 = (Dali::Texture *)jarg1;
24604   argp2 = (Dali::PixelData *)jarg2;
24605   if (!argp2) {
24606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24607     return 0;
24608   }
24609   arg2 = *argp2;
24610   arg3 = (unsigned int)jarg3;
24611   arg4 = (unsigned int)jarg4;
24612   arg5 = (unsigned int)jarg5;
24613   arg6 = (unsigned int)jarg6;
24614   arg7 = (unsigned int)jarg7;
24615   arg8 = (unsigned int)jarg8;
24616   {
24617     try {
24618       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24619     } catch (std::out_of_range& e) {
24620       {
24621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24622       };
24623     } catch (std::exception& e) {
24624       {
24625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24626       };
24627     } catch (Dali::DaliException e) {
24628       {
24629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24630       };
24631     } catch (...) {
24632       {
24633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24634       };
24635     }
24636   }
24637
24638   jresult = result;
24639   return jresult;
24640 }
24641
24642
24643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24644   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24645
24646   arg1 = (Dali::Texture *)jarg1;
24647   {
24648     try {
24649       (arg1)->GenerateMipmaps();
24650     } catch (std::out_of_range& e) {
24651       {
24652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24653       };
24654     } catch (std::exception& e) {
24655       {
24656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24657       };
24658     } catch (Dali::DaliException e) {
24659       {
24660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24661       };
24662     } catch (...) {
24663       {
24664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24665       };
24666     }
24667   }
24668
24669 }
24670
24671
24672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24673   unsigned int jresult ;
24674   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24675   unsigned int result;
24676
24677   arg1 = (Dali::Texture *)jarg1;
24678   {
24679     try {
24680       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24681     } catch (std::out_of_range& e) {
24682       {
24683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24684       };
24685     } catch (std::exception& e) {
24686       {
24687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24688       };
24689     } catch (Dali::DaliException e) {
24690       {
24691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24692       };
24693     } catch (...) {
24694       {
24695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24696       };
24697     }
24698   }
24699
24700   jresult = result;
24701   return jresult;
24702 }
24703
24704
24705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24706   unsigned int jresult ;
24707   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24708   unsigned int result;
24709
24710   arg1 = (Dali::Texture *)jarg1;
24711   {
24712     try {
24713       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24714     } catch (std::out_of_range& e) {
24715       {
24716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24717       };
24718     } catch (std::exception& e) {
24719       {
24720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24721       };
24722     } catch (Dali::DaliException e) {
24723       {
24724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24725       };
24726     } catch (...) {
24727       {
24728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24729       };
24730     }
24731   }
24732
24733   jresult = result;
24734   return jresult;
24735 }
24736
24737
24738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24739   void * jresult ;
24740   Dali::Sampler result;
24741
24742   {
24743     try {
24744       result = Dali::Sampler::New();
24745     } catch (std::out_of_range& e) {
24746       {
24747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24748       };
24749     } catch (std::exception& e) {
24750       {
24751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24752       };
24753     } catch (Dali::DaliException e) {
24754       {
24755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24756       };
24757     } catch (...) {
24758       {
24759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24760       };
24761     }
24762   }
24763
24764   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24765   return jresult;
24766 }
24767
24768
24769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24770   void * jresult ;
24771   Dali::Sampler *result = 0 ;
24772
24773   {
24774     try {
24775       result = (Dali::Sampler *)new Dali::Sampler();
24776     } catch (std::out_of_range& e) {
24777       {
24778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24779       };
24780     } catch (std::exception& e) {
24781       {
24782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24783       };
24784     } catch (Dali::DaliException e) {
24785       {
24786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24787       };
24788     } catch (...) {
24789       {
24790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24791       };
24792     }
24793   }
24794
24795   jresult = (void *)result;
24796   return jresult;
24797 }
24798
24799
24800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24801   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24802
24803   arg1 = (Dali::Sampler *)jarg1;
24804   {
24805     try {
24806       delete arg1;
24807     } catch (std::out_of_range& e) {
24808       {
24809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24810       };
24811     } catch (std::exception& e) {
24812       {
24813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24814       };
24815     } catch (Dali::DaliException e) {
24816       {
24817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24818       };
24819     } catch (...) {
24820       {
24821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24822       };
24823     }
24824   }
24825
24826 }
24827
24828
24829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24830   void * jresult ;
24831   Dali::Sampler *arg1 = 0 ;
24832   Dali::Sampler *result = 0 ;
24833
24834   arg1 = (Dali::Sampler *)jarg1;
24835   if (!arg1) {
24836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24837     return 0;
24838   }
24839   {
24840     try {
24841       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24842     } catch (std::out_of_range& e) {
24843       {
24844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24845       };
24846     } catch (std::exception& e) {
24847       {
24848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24849       };
24850     } catch (Dali::DaliException e) {
24851       {
24852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24853       };
24854     } catch (...) {
24855       {
24856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24857       };
24858     }
24859   }
24860
24861   jresult = (void *)result;
24862   return jresult;
24863 }
24864
24865
24866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24867   void * jresult ;
24868   Dali::BaseHandle arg1 ;
24869   Dali::BaseHandle *argp1 ;
24870   Dali::Sampler result;
24871
24872   argp1 = (Dali::BaseHandle *)jarg1;
24873   if (!argp1) {
24874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24875     return 0;
24876   }
24877   arg1 = *argp1;
24878   {
24879     try {
24880       result = Dali::Sampler::DownCast(arg1);
24881     } catch (std::out_of_range& e) {
24882       {
24883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24884       };
24885     } catch (std::exception& e) {
24886       {
24887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24888       };
24889     } catch (Dali::DaliException e) {
24890       {
24891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24892       };
24893     } catch (...) {
24894       {
24895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24896       };
24897     }
24898   }
24899
24900   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24901   return jresult;
24902 }
24903
24904
24905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24906   void * jresult ;
24907   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24908   Dali::Sampler *arg2 = 0 ;
24909   Dali::Sampler *result = 0 ;
24910
24911   arg1 = (Dali::Sampler *)jarg1;
24912   arg2 = (Dali::Sampler *)jarg2;
24913   if (!arg2) {
24914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24915     return 0;
24916   }
24917   {
24918     try {
24919       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24920     } catch (std::out_of_range& e) {
24921       {
24922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24923       };
24924     } catch (std::exception& e) {
24925       {
24926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24927       };
24928     } catch (Dali::DaliException e) {
24929       {
24930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24931       };
24932     } catch (...) {
24933       {
24934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24935       };
24936     }
24937   }
24938
24939   jresult = (void *)result;
24940   return jresult;
24941 }
24942
24943
24944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24945   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24946   Dali::FilterMode::Type arg2 ;
24947   Dali::FilterMode::Type arg3 ;
24948
24949   arg1 = (Dali::Sampler *)jarg1;
24950   arg2 = (Dali::FilterMode::Type)jarg2;
24951   arg3 = (Dali::FilterMode::Type)jarg3;
24952   {
24953     try {
24954       (arg1)->SetFilterMode(arg2,arg3);
24955     } catch (std::out_of_range& e) {
24956       {
24957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24958       };
24959     } catch (std::exception& e) {
24960       {
24961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24962       };
24963     } catch (Dali::DaliException e) {
24964       {
24965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24966       };
24967     } catch (...) {
24968       {
24969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24970       };
24971     }
24972   }
24973
24974 }
24975
24976
24977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24978   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24979   Dali::WrapMode::Type arg2 ;
24980   Dali::WrapMode::Type arg3 ;
24981
24982   arg1 = (Dali::Sampler *)jarg1;
24983   arg2 = (Dali::WrapMode::Type)jarg2;
24984   arg3 = (Dali::WrapMode::Type)jarg3;
24985   {
24986     try {
24987       (arg1)->SetWrapMode(arg2,arg3);
24988     } catch (std::out_of_range& e) {
24989       {
24990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24991       };
24992     } catch (std::exception& e) {
24993       {
24994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24995       };
24996     } catch (Dali::DaliException e) {
24997       {
24998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24999       };
25000     } catch (...) {
25001       {
25002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25003       };
25004     }
25005   }
25006
25007 }
25008
25009
25010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25011   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25012   Dali::WrapMode::Type arg2 ;
25013   Dali::WrapMode::Type arg3 ;
25014   Dali::WrapMode::Type arg4 ;
25015
25016   arg1 = (Dali::Sampler *)jarg1;
25017   arg2 = (Dali::WrapMode::Type)jarg2;
25018   arg3 = (Dali::WrapMode::Type)jarg3;
25019   arg4 = (Dali::WrapMode::Type)jarg4;
25020   {
25021     try {
25022       (arg1)->SetWrapMode(arg2,arg3,arg4);
25023     } catch (std::out_of_range& e) {
25024       {
25025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25026       };
25027     } catch (std::exception& e) {
25028       {
25029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25030       };
25031     } catch (Dali::DaliException e) {
25032       {
25033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25034       };
25035     } catch (...) {
25036       {
25037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25038       };
25039     }
25040   }
25041
25042 }
25043
25044
25045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25046   void * jresult ;
25047   Dali::TextureSet result;
25048
25049   {
25050     try {
25051       result = Dali::TextureSet::New();
25052     } catch (std::out_of_range& e) {
25053       {
25054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25055       };
25056     } catch (std::exception& e) {
25057       {
25058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25059       };
25060     } catch (Dali::DaliException e) {
25061       {
25062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25063       };
25064     } catch (...) {
25065       {
25066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25067       };
25068     }
25069   }
25070
25071   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25072   return jresult;
25073 }
25074
25075
25076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25077   void * jresult ;
25078   Dali::TextureSet *result = 0 ;
25079
25080   {
25081     try {
25082       result = (Dali::TextureSet *)new Dali::TextureSet();
25083     } catch (std::out_of_range& e) {
25084       {
25085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25086       };
25087     } catch (std::exception& e) {
25088       {
25089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25090       };
25091     } catch (Dali::DaliException e) {
25092       {
25093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25094       };
25095     } catch (...) {
25096       {
25097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25098       };
25099     }
25100   }
25101
25102   jresult = (void *)result;
25103   return jresult;
25104 }
25105
25106
25107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25108   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25109
25110   arg1 = (Dali::TextureSet *)jarg1;
25111   {
25112     try {
25113       delete arg1;
25114     } catch (std::out_of_range& e) {
25115       {
25116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25117       };
25118     } catch (std::exception& e) {
25119       {
25120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25121       };
25122     } catch (Dali::DaliException e) {
25123       {
25124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25125       };
25126     } catch (...) {
25127       {
25128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25129       };
25130     }
25131   }
25132
25133 }
25134
25135
25136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25137   void * jresult ;
25138   Dali::TextureSet *arg1 = 0 ;
25139   Dali::TextureSet *result = 0 ;
25140
25141   arg1 = (Dali::TextureSet *)jarg1;
25142   if (!arg1) {
25143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25144     return 0;
25145   }
25146   {
25147     try {
25148       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25149     } catch (std::out_of_range& e) {
25150       {
25151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25152       };
25153     } catch (std::exception& e) {
25154       {
25155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25156       };
25157     } catch (Dali::DaliException e) {
25158       {
25159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25160       };
25161     } catch (...) {
25162       {
25163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25164       };
25165     }
25166   }
25167
25168   jresult = (void *)result;
25169   return jresult;
25170 }
25171
25172
25173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25174   void * jresult ;
25175   Dali::BaseHandle arg1 ;
25176   Dali::BaseHandle *argp1 ;
25177   Dali::TextureSet result;
25178
25179   argp1 = (Dali::BaseHandle *)jarg1;
25180   if (!argp1) {
25181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25182     return 0;
25183   }
25184   arg1 = *argp1;
25185   {
25186     try {
25187       result = Dali::TextureSet::DownCast(arg1);
25188     } catch (std::out_of_range& e) {
25189       {
25190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25191       };
25192     } catch (std::exception& e) {
25193       {
25194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25195       };
25196     } catch (Dali::DaliException e) {
25197       {
25198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25199       };
25200     } catch (...) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25203       };
25204     }
25205   }
25206
25207   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25208   return jresult;
25209 }
25210
25211
25212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25213   void * jresult ;
25214   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25215   Dali::TextureSet *arg2 = 0 ;
25216   Dali::TextureSet *result = 0 ;
25217
25218   arg1 = (Dali::TextureSet *)jarg1;
25219   arg2 = (Dali::TextureSet *)jarg2;
25220   if (!arg2) {
25221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25222     return 0;
25223   }
25224   {
25225     try {
25226       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25227     } catch (std::out_of_range& e) {
25228       {
25229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25230       };
25231     } catch (std::exception& e) {
25232       {
25233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25234       };
25235     } catch (Dali::DaliException e) {
25236       {
25237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25238       };
25239     } catch (...) {
25240       {
25241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25242       };
25243     }
25244   }
25245
25246   jresult = (void *)result;
25247   return jresult;
25248 }
25249
25250
25251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25252   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25253   size_t arg2 ;
25254   Dali::Texture arg3 ;
25255   Dali::Texture *argp3 ;
25256
25257   arg1 = (Dali::TextureSet *)jarg1;
25258   arg2 = (size_t)jarg2;
25259   argp3 = (Dali::Texture *)jarg3;
25260   if (!argp3) {
25261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25262     return ;
25263   }
25264   arg3 = *argp3;
25265   {
25266     try {
25267       (arg1)->SetTexture(arg2,arg3);
25268     } catch (std::out_of_range& e) {
25269       {
25270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25271       };
25272     } catch (std::exception& e) {
25273       {
25274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25275       };
25276     } catch (Dali::DaliException e) {
25277       {
25278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25279       };
25280     } catch (...) {
25281       {
25282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25283       };
25284     }
25285   }
25286
25287 }
25288
25289
25290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25291   void * jresult ;
25292   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25293   size_t arg2 ;
25294   Dali::Texture result;
25295
25296   arg1 = (Dali::TextureSet *)jarg1;
25297   arg2 = (size_t)jarg2;
25298   {
25299     try {
25300       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25301     } catch (std::out_of_range& e) {
25302       {
25303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25304       };
25305     } catch (std::exception& e) {
25306       {
25307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25308       };
25309     } catch (Dali::DaliException e) {
25310       {
25311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25312       };
25313     } catch (...) {
25314       {
25315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25316       };
25317     }
25318   }
25319
25320   jresult = new Dali::Texture((const Dali::Texture &)result);
25321   return jresult;
25322 }
25323
25324
25325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25326   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25327   size_t arg2 ;
25328   Dali::Sampler arg3 ;
25329   Dali::Sampler *argp3 ;
25330
25331   arg1 = (Dali::TextureSet *)jarg1;
25332   arg2 = (size_t)jarg2;
25333   argp3 = (Dali::Sampler *)jarg3;
25334   if (!argp3) {
25335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25336     return ;
25337   }
25338   arg3 = *argp3;
25339   {
25340     try {
25341       (arg1)->SetSampler(arg2,arg3);
25342     } catch (std::out_of_range& e) {
25343       {
25344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25345       };
25346     } catch (std::exception& e) {
25347       {
25348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25349       };
25350     } catch (Dali::DaliException e) {
25351       {
25352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25353       };
25354     } catch (...) {
25355       {
25356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25357       };
25358     }
25359   }
25360
25361 }
25362
25363
25364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25365   void * jresult ;
25366   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25367   size_t arg2 ;
25368   Dali::Sampler result;
25369
25370   arg1 = (Dali::TextureSet *)jarg1;
25371   arg2 = (size_t)jarg2;
25372   {
25373     try {
25374       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25375     } catch (std::out_of_range& e) {
25376       {
25377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25378       };
25379     } catch (std::exception& e) {
25380       {
25381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25382       };
25383     } catch (Dali::DaliException e) {
25384       {
25385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25386       };
25387     } catch (...) {
25388       {
25389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25390       };
25391     }
25392   }
25393
25394   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25395   return jresult;
25396 }
25397
25398
25399 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25400   unsigned long jresult ;
25401   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25402   size_t result;
25403
25404   arg1 = (Dali::TextureSet *)jarg1;
25405   {
25406     try {
25407       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25408     } catch (std::out_of_range& e) {
25409       {
25410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25411       };
25412     } catch (std::exception& e) {
25413       {
25414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25415       };
25416     } catch (Dali::DaliException e) {
25417       {
25418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25419       };
25420     } catch (...) {
25421       {
25422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25423       };
25424     }
25425   }
25426
25427   jresult = (unsigned long)result;
25428   return jresult;
25429 }
25430
25431
25432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25433   void * jresult ;
25434   Dali::Property::Map *arg1 = 0 ;
25435   Dali::PropertyBuffer result;
25436
25437   arg1 = (Dali::Property::Map *)jarg1;
25438   if (!arg1) {
25439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25440     return 0;
25441   }
25442   {
25443     try {
25444       result = Dali::PropertyBuffer::New(*arg1);
25445     } catch (std::out_of_range& e) {
25446       {
25447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25448       };
25449     } catch (std::exception& e) {
25450       {
25451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25452       };
25453     } catch (Dali::DaliException e) {
25454       {
25455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25456       };
25457     } catch (...) {
25458       {
25459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25460       };
25461     }
25462   }
25463
25464   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25465   return jresult;
25466 }
25467
25468
25469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25470   void * jresult ;
25471   Dali::PropertyBuffer *result = 0 ;
25472
25473   {
25474     try {
25475       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25476     } catch (std::out_of_range& e) {
25477       {
25478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25479       };
25480     } catch (std::exception& e) {
25481       {
25482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25483       };
25484     } catch (Dali::DaliException e) {
25485       {
25486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25487       };
25488     } catch (...) {
25489       {
25490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25491       };
25492     }
25493   }
25494
25495   jresult = (void *)result;
25496   return jresult;
25497 }
25498
25499
25500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25501   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25502
25503   arg1 = (Dali::PropertyBuffer *)jarg1;
25504   {
25505     try {
25506       delete arg1;
25507     } catch (std::out_of_range& e) {
25508       {
25509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25510       };
25511     } catch (std::exception& e) {
25512       {
25513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25514       };
25515     } catch (Dali::DaliException e) {
25516       {
25517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25518       };
25519     } catch (...) {
25520       {
25521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25522       };
25523     }
25524   }
25525
25526 }
25527
25528
25529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25530   void * jresult ;
25531   Dali::PropertyBuffer *arg1 = 0 ;
25532   Dali::PropertyBuffer *result = 0 ;
25533
25534   arg1 = (Dali::PropertyBuffer *)jarg1;
25535   if (!arg1) {
25536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25537     return 0;
25538   }
25539   {
25540     try {
25541       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25542     } catch (std::out_of_range& e) {
25543       {
25544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25545       };
25546     } catch (std::exception& e) {
25547       {
25548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25549       };
25550     } catch (Dali::DaliException e) {
25551       {
25552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25553       };
25554     } catch (...) {
25555       {
25556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25557       };
25558     }
25559   }
25560
25561   jresult = (void *)result;
25562   return jresult;
25563 }
25564
25565
25566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25567   void * jresult ;
25568   Dali::BaseHandle arg1 ;
25569   Dali::BaseHandle *argp1 ;
25570   Dali::PropertyBuffer result;
25571
25572   argp1 = (Dali::BaseHandle *)jarg1;
25573   if (!argp1) {
25574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25575     return 0;
25576   }
25577   arg1 = *argp1;
25578   {
25579     try {
25580       result = Dali::PropertyBuffer::DownCast(arg1);
25581     } catch (std::out_of_range& e) {
25582       {
25583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25584       };
25585     } catch (std::exception& e) {
25586       {
25587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25588       };
25589     } catch (Dali::DaliException e) {
25590       {
25591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25592       };
25593     } catch (...) {
25594       {
25595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25596       };
25597     }
25598   }
25599
25600   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25601   return jresult;
25602 }
25603
25604
25605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25606   void * jresult ;
25607   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25608   Dali::PropertyBuffer *arg2 = 0 ;
25609   Dali::PropertyBuffer *result = 0 ;
25610
25611   arg1 = (Dali::PropertyBuffer *)jarg1;
25612   arg2 = (Dali::PropertyBuffer *)jarg2;
25613   if (!arg2) {
25614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25615     return 0;
25616   }
25617   {
25618     try {
25619       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25620     } catch (std::out_of_range& e) {
25621       {
25622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25623       };
25624     } catch (std::exception& e) {
25625       {
25626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25627       };
25628     } catch (Dali::DaliException e) {
25629       {
25630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25631       };
25632     } catch (...) {
25633       {
25634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25635       };
25636     }
25637   }
25638
25639   jresult = (void *)result;
25640   return jresult;
25641 }
25642
25643
25644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25645   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25646   void *arg2 = (void *) 0 ;
25647   std::size_t arg3 ;
25648
25649   arg1 = (Dali::PropertyBuffer *)jarg1;
25650   arg2 = jarg2;
25651   arg3 = (std::size_t)jarg3;
25652   {
25653     try {
25654       (arg1)->SetData((void const *)arg2,arg3);
25655     } catch (std::out_of_range& e) {
25656       {
25657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25658       };
25659     } catch (std::exception& e) {
25660       {
25661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25662       };
25663     } catch (Dali::DaliException e) {
25664       {
25665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25666       };
25667     } catch (...) {
25668       {
25669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25670       };
25671     }
25672   }
25673
25674 }
25675
25676
25677 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25678   unsigned long jresult ;
25679   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25680   std::size_t result;
25681
25682   arg1 = (Dali::PropertyBuffer *)jarg1;
25683   {
25684     try {
25685       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25686     } catch (std::out_of_range& e) {
25687       {
25688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25689       };
25690     } catch (std::exception& e) {
25691       {
25692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25693       };
25694     } catch (Dali::DaliException e) {
25695       {
25696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25697       };
25698     } catch (...) {
25699       {
25700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25701       };
25702     }
25703   }
25704
25705   jresult = (unsigned long)result;
25706   return jresult;
25707 }
25708
25709
25710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25711   void * jresult ;
25712   Dali::Geometry result;
25713
25714   {
25715     try {
25716       result = Dali::Geometry::New();
25717     } catch (std::out_of_range& e) {
25718       {
25719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25720       };
25721     } catch (std::exception& e) {
25722       {
25723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25724       };
25725     } catch (Dali::DaliException e) {
25726       {
25727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25728       };
25729     } catch (...) {
25730       {
25731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25732       };
25733     }
25734   }
25735
25736   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25737   return jresult;
25738 }
25739
25740
25741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25742   void * jresult ;
25743   Dali::Geometry *result = 0 ;
25744
25745   {
25746     try {
25747       result = (Dali::Geometry *)new Dali::Geometry();
25748     } catch (std::out_of_range& e) {
25749       {
25750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25751       };
25752     } catch (std::exception& e) {
25753       {
25754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25755       };
25756     } catch (Dali::DaliException e) {
25757       {
25758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25759       };
25760     } catch (...) {
25761       {
25762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25763       };
25764     }
25765   }
25766
25767   jresult = (void *)result;
25768   return jresult;
25769 }
25770
25771
25772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25773   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25774
25775   arg1 = (Dali::Geometry *)jarg1;
25776   {
25777     try {
25778       delete arg1;
25779     } catch (std::out_of_range& e) {
25780       {
25781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25782       };
25783     } catch (std::exception& e) {
25784       {
25785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25786       };
25787     } catch (Dali::DaliException e) {
25788       {
25789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25790       };
25791     } catch (...) {
25792       {
25793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25794       };
25795     }
25796   }
25797
25798 }
25799
25800
25801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25802   void * jresult ;
25803   Dali::Geometry *arg1 = 0 ;
25804   Dali::Geometry *result = 0 ;
25805
25806   arg1 = (Dali::Geometry *)jarg1;
25807   if (!arg1) {
25808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25809     return 0;
25810   }
25811   {
25812     try {
25813       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25814     } catch (std::out_of_range& e) {
25815       {
25816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25817       };
25818     } catch (std::exception& e) {
25819       {
25820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25821       };
25822     } catch (Dali::DaliException e) {
25823       {
25824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25825       };
25826     } catch (...) {
25827       {
25828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25829       };
25830     }
25831   }
25832
25833   jresult = (void *)result;
25834   return jresult;
25835 }
25836
25837
25838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25839   void * jresult ;
25840   Dali::BaseHandle arg1 ;
25841   Dali::BaseHandle *argp1 ;
25842   Dali::Geometry result;
25843
25844   argp1 = (Dali::BaseHandle *)jarg1;
25845   if (!argp1) {
25846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25847     return 0;
25848   }
25849   arg1 = *argp1;
25850   {
25851     try {
25852       result = Dali::Geometry::DownCast(arg1);
25853     } catch (std::out_of_range& e) {
25854       {
25855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25856       };
25857     } catch (std::exception& e) {
25858       {
25859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25860       };
25861     } catch (Dali::DaliException e) {
25862       {
25863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25864       };
25865     } catch (...) {
25866       {
25867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25868       };
25869     }
25870   }
25871
25872   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25873   return jresult;
25874 }
25875
25876
25877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25878   void * jresult ;
25879   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25880   Dali::Geometry *arg2 = 0 ;
25881   Dali::Geometry *result = 0 ;
25882
25883   arg1 = (Dali::Geometry *)jarg1;
25884   arg2 = (Dali::Geometry *)jarg2;
25885   if (!arg2) {
25886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25887     return 0;
25888   }
25889   {
25890     try {
25891       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25892     } catch (std::out_of_range& e) {
25893       {
25894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25895       };
25896     } catch (std::exception& e) {
25897       {
25898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25899       };
25900     } catch (Dali::DaliException e) {
25901       {
25902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25903       };
25904     } catch (...) {
25905       {
25906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25907       };
25908     }
25909   }
25910
25911   jresult = (void *)result;
25912   return jresult;
25913 }
25914
25915
25916 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25917   unsigned long jresult ;
25918   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25919   Dali::PropertyBuffer *arg2 = 0 ;
25920   std::size_t result;
25921
25922   arg1 = (Dali::Geometry *)jarg1;
25923   arg2 = (Dali::PropertyBuffer *)jarg2;
25924   if (!arg2) {
25925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25926     return 0;
25927   }
25928   {
25929     try {
25930       result = (arg1)->AddVertexBuffer(*arg2);
25931     } catch (std::out_of_range& e) {
25932       {
25933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25934       };
25935     } catch (std::exception& e) {
25936       {
25937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25938       };
25939     } catch (Dali::DaliException e) {
25940       {
25941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25942       };
25943     } catch (...) {
25944       {
25945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25946       };
25947     }
25948   }
25949
25950   jresult = (unsigned long)result;
25951   return jresult;
25952 }
25953
25954
25955 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25956   unsigned long jresult ;
25957   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25958   std::size_t result;
25959
25960   arg1 = (Dali::Geometry *)jarg1;
25961   {
25962     try {
25963       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25964     } catch (std::out_of_range& e) {
25965       {
25966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25967       };
25968     } catch (std::exception& e) {
25969       {
25970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25971       };
25972     } catch (Dali::DaliException e) {
25973       {
25974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25975       };
25976     } catch (...) {
25977       {
25978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25979       };
25980     }
25981   }
25982
25983   jresult = (unsigned long)result;
25984   return jresult;
25985 }
25986
25987
25988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25989   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25990   std::size_t arg2 ;
25991
25992   arg1 = (Dali::Geometry *)jarg1;
25993   arg2 = (std::size_t)jarg2;
25994   {
25995     try {
25996       (arg1)->RemoveVertexBuffer(arg2);
25997     } catch (std::out_of_range& e) {
25998       {
25999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26000       };
26001     } catch (std::exception& e) {
26002       {
26003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26004       };
26005     } catch (Dali::DaliException e) {
26006       {
26007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26008       };
26009     } catch (...) {
26010       {
26011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26012       };
26013     }
26014   }
26015
26016 }
26017
26018
26019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26020   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26021   unsigned short *arg2 = (unsigned short *) 0 ;
26022   size_t arg3 ;
26023
26024   arg1 = (Dali::Geometry *)jarg1;
26025   arg2 = jarg2;
26026   arg3 = (size_t)jarg3;
26027   {
26028     try {
26029       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26030     } catch (std::out_of_range& e) {
26031       {
26032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26033       };
26034     } catch (std::exception& e) {
26035       {
26036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26037       };
26038     } catch (Dali::DaliException e) {
26039       {
26040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26041       };
26042     } catch (...) {
26043       {
26044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26045       };
26046     }
26047   }
26048
26049
26050
26051 }
26052
26053
26054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26055   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26056   Dali::Geometry::Type arg2 ;
26057
26058   arg1 = (Dali::Geometry *)jarg1;
26059   arg2 = (Dali::Geometry::Type)jarg2;
26060   {
26061     try {
26062       (arg1)->SetType(arg2);
26063     } catch (std::out_of_range& e) {
26064       {
26065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26066       };
26067     } catch (std::exception& e) {
26068       {
26069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26070       };
26071     } catch (Dali::DaliException e) {
26072       {
26073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26074       };
26075     } catch (...) {
26076       {
26077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26078       };
26079     }
26080   }
26081
26082 }
26083
26084
26085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26086   int jresult ;
26087   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26088   Dali::Geometry::Type result;
26089
26090   arg1 = (Dali::Geometry *)jarg1;
26091   {
26092     try {
26093       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26094     } catch (std::out_of_range& e) {
26095       {
26096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26097       };
26098     } catch (std::exception& e) {
26099       {
26100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26101       };
26102     } catch (Dali::DaliException e) {
26103       {
26104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26105       };
26106     } catch (...) {
26107       {
26108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26109       };
26110     }
26111   }
26112
26113   jresult = (int)result;
26114   return jresult;
26115 }
26116
26117
26118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26119   void * jresult ;
26120   Dali::Shader::Hint *result = 0 ;
26121
26122   {
26123     try {
26124       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26125     } catch (std::out_of_range& e) {
26126       {
26127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26128       };
26129     } catch (std::exception& e) {
26130       {
26131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26132       };
26133     } catch (Dali::DaliException e) {
26134       {
26135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26136       };
26137     } catch (...) {
26138       {
26139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26140       };
26141     }
26142   }
26143
26144   jresult = (void *)result;
26145   return jresult;
26146 }
26147
26148
26149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26150   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26151
26152   arg1 = (Dali::Shader::Hint *)jarg1;
26153   {
26154     try {
26155       delete arg1;
26156     } catch (std::out_of_range& e) {
26157       {
26158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26159       };
26160     } catch (std::exception& e) {
26161       {
26162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26163       };
26164     } catch (Dali::DaliException e) {
26165       {
26166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26167       };
26168     } catch (...) {
26169       {
26170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26171       };
26172     }
26173   }
26174
26175 }
26176
26177
26178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26179   int jresult ;
26180   int result;
26181
26182   result = (int)Dali::Shader::Property::PROGRAM;
26183   jresult = (int)result;
26184   return jresult;
26185 }
26186
26187
26188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26189   void * jresult ;
26190   Dali::Shader::Property *result = 0 ;
26191
26192   {
26193     try {
26194       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26195     } catch (std::out_of_range& e) {
26196       {
26197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26198       };
26199     } catch (std::exception& e) {
26200       {
26201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26202       };
26203     } catch (Dali::DaliException e) {
26204       {
26205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26206       };
26207     } catch (...) {
26208       {
26209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26210       };
26211     }
26212   }
26213
26214   jresult = (void *)result;
26215   return jresult;
26216 }
26217
26218
26219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26220   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26221
26222   arg1 = (Dali::Shader::Property *)jarg1;
26223   {
26224     try {
26225       delete arg1;
26226     } catch (std::out_of_range& e) {
26227       {
26228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26229       };
26230     } catch (std::exception& e) {
26231       {
26232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26233       };
26234     } catch (Dali::DaliException e) {
26235       {
26236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26237       };
26238     } catch (...) {
26239       {
26240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26241       };
26242     }
26243   }
26244
26245 }
26246
26247
26248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26249   void * jresult ;
26250   std::string *arg1 = 0 ;
26251   std::string *arg2 = 0 ;
26252   Dali::Shader::Hint::Value arg3 ;
26253   Dali::Shader result;
26254
26255   if (!jarg1) {
26256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26257     return 0;
26258   }
26259   std::string arg1_str(jarg1);
26260   arg1 = &arg1_str;
26261   if (!jarg2) {
26262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26263     return 0;
26264   }
26265   std::string arg2_str(jarg2);
26266   arg2 = &arg2_str;
26267   arg3 = (Dali::Shader::Hint::Value)jarg3;
26268   {
26269     try {
26270       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26271     } catch (std::out_of_range& e) {
26272       {
26273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26274       };
26275     } catch (std::exception& e) {
26276       {
26277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26278       };
26279     } catch (Dali::DaliException e) {
26280       {
26281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26282       };
26283     } catch (...) {
26284       {
26285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26286       };
26287     }
26288   }
26289
26290   jresult = new Dali::Shader((const Dali::Shader &)result);
26291
26292   //argout typemap for const std::string&
26293
26294
26295   //argout typemap for const std::string&
26296
26297   return jresult;
26298 }
26299
26300
26301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26302   void * jresult ;
26303   std::string *arg1 = 0 ;
26304   std::string *arg2 = 0 ;
26305   Dali::Shader result;
26306
26307   if (!jarg1) {
26308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26309     return 0;
26310   }
26311   std::string arg1_str(jarg1);
26312   arg1 = &arg1_str;
26313   if (!jarg2) {
26314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26315     return 0;
26316   }
26317   std::string arg2_str(jarg2);
26318   arg2 = &arg2_str;
26319   {
26320     try {
26321       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26322     } catch (std::out_of_range& e) {
26323       {
26324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26325       };
26326     } catch (std::exception& e) {
26327       {
26328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26329       };
26330     } catch (Dali::DaliException e) {
26331       {
26332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26333       };
26334     } catch (...) {
26335       {
26336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26337       };
26338     }
26339   }
26340
26341   jresult = new Dali::Shader((const Dali::Shader &)result);
26342
26343   //argout typemap for const std::string&
26344
26345
26346   //argout typemap for const std::string&
26347
26348   return jresult;
26349 }
26350
26351
26352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26353   void * jresult ;
26354   Dali::Shader *result = 0 ;
26355
26356   {
26357     try {
26358       result = (Dali::Shader *)new Dali::Shader();
26359     } catch (std::out_of_range& e) {
26360       {
26361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26362       };
26363     } catch (std::exception& e) {
26364       {
26365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26366       };
26367     } catch (Dali::DaliException e) {
26368       {
26369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26370       };
26371     } catch (...) {
26372       {
26373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26374       };
26375     }
26376   }
26377
26378   jresult = (void *)result;
26379   return jresult;
26380 }
26381
26382
26383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26384   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26385
26386   arg1 = (Dali::Shader *)jarg1;
26387   {
26388     try {
26389       delete arg1;
26390     } catch (std::out_of_range& e) {
26391       {
26392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26393       };
26394     } catch (std::exception& e) {
26395       {
26396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26397       };
26398     } catch (Dali::DaliException e) {
26399       {
26400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26401       };
26402     } catch (...) {
26403       {
26404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26405       };
26406     }
26407   }
26408
26409 }
26410
26411
26412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26413   void * jresult ;
26414   Dali::Shader *arg1 = 0 ;
26415   Dali::Shader *result = 0 ;
26416
26417   arg1 = (Dali::Shader *)jarg1;
26418   if (!arg1) {
26419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26420     return 0;
26421   }
26422   {
26423     try {
26424       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26425     } catch (std::out_of_range& e) {
26426       {
26427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26428       };
26429     } catch (std::exception& e) {
26430       {
26431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26432       };
26433     } catch (Dali::DaliException e) {
26434       {
26435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26436       };
26437     } catch (...) {
26438       {
26439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26440       };
26441     }
26442   }
26443
26444   jresult = (void *)result;
26445   return jresult;
26446 }
26447
26448
26449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26450   void * jresult ;
26451   Dali::BaseHandle arg1 ;
26452   Dali::BaseHandle *argp1 ;
26453   Dali::Shader result;
26454
26455   argp1 = (Dali::BaseHandle *)jarg1;
26456   if (!argp1) {
26457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26458     return 0;
26459   }
26460   arg1 = *argp1;
26461   {
26462     try {
26463       result = Dali::Shader::DownCast(arg1);
26464     } catch (std::out_of_range& e) {
26465       {
26466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26467       };
26468     } catch (std::exception& e) {
26469       {
26470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26471       };
26472     } catch (Dali::DaliException e) {
26473       {
26474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26475       };
26476     } catch (...) {
26477       {
26478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26479       };
26480     }
26481   }
26482
26483   jresult = new Dali::Shader((const Dali::Shader &)result);
26484   return jresult;
26485 }
26486
26487
26488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26489   void * jresult ;
26490   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26491   Dali::Shader *arg2 = 0 ;
26492   Dali::Shader *result = 0 ;
26493
26494   arg1 = (Dali::Shader *)jarg1;
26495   arg2 = (Dali::Shader *)jarg2;
26496   if (!arg2) {
26497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26498     return 0;
26499   }
26500   {
26501     try {
26502       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26503     } catch (std::out_of_range& e) {
26504       {
26505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26506       };
26507     } catch (std::exception& e) {
26508       {
26509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26510       };
26511     } catch (Dali::DaliException e) {
26512       {
26513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26514       };
26515     } catch (...) {
26516       {
26517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26518       };
26519     }
26520   }
26521
26522   jresult = (void *)result;
26523   return jresult;
26524 }
26525
26526
26527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26528   int jresult ;
26529   int result;
26530
26531   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26532   jresult = (int)result;
26533   return jresult;
26534 }
26535
26536
26537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26538   int jresult ;
26539   int result;
26540
26541   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26542   jresult = (int)result;
26543   return jresult;
26544 }
26545
26546
26547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26548   int jresult ;
26549   int result;
26550
26551   result = (int)Dali::Renderer::Property::BLEND_MODE;
26552   jresult = (int)result;
26553   return jresult;
26554 }
26555
26556
26557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26558   int jresult ;
26559   int result;
26560
26561   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26562   jresult = (int)result;
26563   return jresult;
26564 }
26565
26566
26567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26568   int jresult ;
26569   int result;
26570
26571   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26572   jresult = (int)result;
26573   return jresult;
26574 }
26575
26576
26577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26578   int jresult ;
26579   int result;
26580
26581   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26582   jresult = (int)result;
26583   return jresult;
26584 }
26585
26586
26587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26588   int jresult ;
26589   int result;
26590
26591   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26592   jresult = (int)result;
26593   return jresult;
26594 }
26595
26596
26597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26598   int jresult ;
26599   int result;
26600
26601   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26602   jresult = (int)result;
26603   return jresult;
26604 }
26605
26606
26607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26608   int jresult ;
26609   int result;
26610
26611   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26612   jresult = (int)result;
26613   return jresult;
26614 }
26615
26616
26617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26618   int jresult ;
26619   int result;
26620
26621   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26622   jresult = (int)result;
26623   return jresult;
26624 }
26625
26626
26627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26628   int jresult ;
26629   int result;
26630
26631   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26632   jresult = (int)result;
26633   return jresult;
26634 }
26635
26636
26637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26638   int jresult ;
26639   int result;
26640
26641   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26642   jresult = (int)result;
26643   return jresult;
26644 }
26645
26646
26647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26648   int jresult ;
26649   int result;
26650
26651   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26652   jresult = (int)result;
26653   return jresult;
26654 }
26655
26656
26657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26658   int jresult ;
26659   int result;
26660
26661   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26662   jresult = (int)result;
26663   return jresult;
26664 }
26665
26666
26667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26668   int jresult ;
26669   int result;
26670
26671   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26672   jresult = (int)result;
26673   return jresult;
26674 }
26675
26676
26677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26678   int jresult ;
26679   int result;
26680
26681   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26682   jresult = (int)result;
26683   return jresult;
26684 }
26685
26686
26687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26688   int jresult ;
26689   int result;
26690
26691   result = (int)Dali::Renderer::Property::RENDER_MODE;
26692   jresult = (int)result;
26693   return jresult;
26694 }
26695
26696
26697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26698   int jresult ;
26699   int result;
26700
26701   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26702   jresult = (int)result;
26703   return jresult;
26704 }
26705
26706
26707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26708   int jresult ;
26709   int result;
26710
26711   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26712   jresult = (int)result;
26713   return jresult;
26714 }
26715
26716
26717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26718   int jresult ;
26719   int result;
26720
26721   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26722   jresult = (int)result;
26723   return jresult;
26724 }
26725
26726
26727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26728   int jresult ;
26729   int result;
26730
26731   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26732   jresult = (int)result;
26733   return jresult;
26734 }
26735
26736
26737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26738   int jresult ;
26739   int result;
26740
26741   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26742   jresult = (int)result;
26743   return jresult;
26744 }
26745
26746
26747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26748   int jresult ;
26749   int result;
26750
26751   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26752   jresult = (int)result;
26753   return jresult;
26754 }
26755
26756
26757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26758   int jresult ;
26759   int result;
26760
26761   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26762   jresult = (int)result;
26763   return jresult;
26764 }
26765
26766
26767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26768   void * jresult ;
26769   Dali::Renderer::Property *result = 0 ;
26770
26771   {
26772     try {
26773       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26774     } catch (std::out_of_range& e) {
26775       {
26776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26777       };
26778     } catch (std::exception& e) {
26779       {
26780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26781       };
26782     } catch (Dali::DaliException e) {
26783       {
26784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26785       };
26786     } catch (...) {
26787       {
26788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26789       };
26790     }
26791   }
26792
26793   jresult = (void *)result;
26794   return jresult;
26795 }
26796
26797
26798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26799   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26800
26801   arg1 = (Dali::Renderer::Property *)jarg1;
26802   {
26803     try {
26804       delete arg1;
26805     } catch (std::out_of_range& e) {
26806       {
26807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26808       };
26809     } catch (std::exception& e) {
26810       {
26811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26812       };
26813     } catch (Dali::DaliException e) {
26814       {
26815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26816       };
26817     } catch (...) {
26818       {
26819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26820       };
26821     }
26822   }
26823
26824 }
26825
26826
26827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26828   void * jresult ;
26829   Dali::Geometry *arg1 = 0 ;
26830   Dali::Shader *arg2 = 0 ;
26831   Dali::Renderer result;
26832
26833   arg1 = (Dali::Geometry *)jarg1;
26834   if (!arg1) {
26835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26836     return 0;
26837   }
26838   arg2 = (Dali::Shader *)jarg2;
26839   if (!arg2) {
26840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26841     return 0;
26842   }
26843   {
26844     try {
26845       result = Dali::Renderer::New(*arg1,*arg2);
26846     } catch (std::out_of_range& e) {
26847       {
26848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26849       };
26850     } catch (std::exception& e) {
26851       {
26852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26853       };
26854     } catch (Dali::DaliException e) {
26855       {
26856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26857       };
26858     } catch (...) {
26859       {
26860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26861       };
26862     }
26863   }
26864
26865   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26866   return jresult;
26867 }
26868
26869
26870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26871   void * jresult ;
26872   Dali::Renderer *result = 0 ;
26873
26874   {
26875     try {
26876       result = (Dali::Renderer *)new Dali::Renderer();
26877     } catch (std::out_of_range& e) {
26878       {
26879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26880       };
26881     } catch (std::exception& e) {
26882       {
26883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26884       };
26885     } catch (Dali::DaliException e) {
26886       {
26887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26888       };
26889     } catch (...) {
26890       {
26891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26892       };
26893     }
26894   }
26895
26896   jresult = (void *)result;
26897   return jresult;
26898 }
26899
26900
26901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26902   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26903
26904   arg1 = (Dali::Renderer *)jarg1;
26905   {
26906     try {
26907       delete arg1;
26908     } catch (std::out_of_range& e) {
26909       {
26910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26911       };
26912     } catch (std::exception& e) {
26913       {
26914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26915       };
26916     } catch (Dali::DaliException e) {
26917       {
26918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26919       };
26920     } catch (...) {
26921       {
26922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26923       };
26924     }
26925   }
26926
26927 }
26928
26929
26930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26931   void * jresult ;
26932   Dali::Renderer *arg1 = 0 ;
26933   Dali::Renderer *result = 0 ;
26934
26935   arg1 = (Dali::Renderer *)jarg1;
26936   if (!arg1) {
26937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26938     return 0;
26939   }
26940   {
26941     try {
26942       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26943     } catch (std::out_of_range& e) {
26944       {
26945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26946       };
26947     } catch (std::exception& e) {
26948       {
26949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26950       };
26951     } catch (Dali::DaliException e) {
26952       {
26953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26954       };
26955     } catch (...) {
26956       {
26957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26958       };
26959     }
26960   }
26961
26962   jresult = (void *)result;
26963   return jresult;
26964 }
26965
26966
26967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26968   void * jresult ;
26969   Dali::BaseHandle arg1 ;
26970   Dali::BaseHandle *argp1 ;
26971   Dali::Renderer result;
26972
26973   argp1 = (Dali::BaseHandle *)jarg1;
26974   if (!argp1) {
26975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26976     return 0;
26977   }
26978   arg1 = *argp1;
26979   {
26980     try {
26981       result = Dali::Renderer::DownCast(arg1);
26982     } catch (std::out_of_range& e) {
26983       {
26984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26985       };
26986     } catch (std::exception& e) {
26987       {
26988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26989       };
26990     } catch (Dali::DaliException e) {
26991       {
26992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26993       };
26994     } catch (...) {
26995       {
26996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26997       };
26998     }
26999   }
27000
27001   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27002   return jresult;
27003 }
27004
27005
27006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27007   void * jresult ;
27008   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27009   Dali::Renderer *arg2 = 0 ;
27010   Dali::Renderer *result = 0 ;
27011
27012   arg1 = (Dali::Renderer *)jarg1;
27013   arg2 = (Dali::Renderer *)jarg2;
27014   if (!arg2) {
27015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27016     return 0;
27017   }
27018   {
27019     try {
27020       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27021     } catch (std::out_of_range& e) {
27022       {
27023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27024       };
27025     } catch (std::exception& e) {
27026       {
27027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27028       };
27029     } catch (Dali::DaliException e) {
27030       {
27031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27032       };
27033     } catch (...) {
27034       {
27035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27036       };
27037     }
27038   }
27039
27040   jresult = (void *)result;
27041   return jresult;
27042 }
27043
27044
27045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27046   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27047   Dali::Geometry *arg2 = 0 ;
27048
27049   arg1 = (Dali::Renderer *)jarg1;
27050   arg2 = (Dali::Geometry *)jarg2;
27051   if (!arg2) {
27052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27053     return ;
27054   }
27055   {
27056     try {
27057       (arg1)->SetGeometry(*arg2);
27058     } catch (std::out_of_range& e) {
27059       {
27060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27061       };
27062     } catch (std::exception& e) {
27063       {
27064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27065       };
27066     } catch (Dali::DaliException e) {
27067       {
27068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27069       };
27070     } catch (...) {
27071       {
27072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27073       };
27074     }
27075   }
27076
27077 }
27078
27079
27080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27081   void * jresult ;
27082   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27083   Dali::Geometry result;
27084
27085   arg1 = (Dali::Renderer *)jarg1;
27086   {
27087     try {
27088       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27089     } catch (std::out_of_range& e) {
27090       {
27091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27092       };
27093     } catch (std::exception& e) {
27094       {
27095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27096       };
27097     } catch (Dali::DaliException e) {
27098       {
27099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27100       };
27101     } catch (...) {
27102       {
27103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27104       };
27105     }
27106   }
27107
27108   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27109   return jresult;
27110 }
27111
27112
27113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27114   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27115   int arg2 ;
27116   int arg3 ;
27117
27118   arg1 = (Dali::Renderer *)jarg1;
27119   arg2 = (int)jarg2;
27120   arg3 = (int)jarg3;
27121   {
27122     try {
27123       (arg1)->SetIndexRange(arg2,arg3);
27124     } catch (std::out_of_range& e) {
27125       {
27126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27127       };
27128     } catch (std::exception& e) {
27129       {
27130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27131       };
27132     } catch (Dali::DaliException e) {
27133       {
27134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27135       };
27136     } catch (...) {
27137       {
27138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27139       };
27140     }
27141   }
27142
27143 }
27144
27145
27146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27147   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27148   Dali::TextureSet *arg2 = 0 ;
27149
27150   arg1 = (Dali::Renderer *)jarg1;
27151   arg2 = (Dali::TextureSet *)jarg2;
27152   if (!arg2) {
27153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27154     return ;
27155   }
27156   {
27157     try {
27158       (arg1)->SetTextures(*arg2);
27159     } catch (std::out_of_range& e) {
27160       {
27161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27162       };
27163     } catch (std::exception& e) {
27164       {
27165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27166       };
27167     } catch (Dali::DaliException e) {
27168       {
27169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27170       };
27171     } catch (...) {
27172       {
27173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27174       };
27175     }
27176   }
27177
27178 }
27179
27180
27181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27182   void * jresult ;
27183   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27184   Dali::TextureSet result;
27185
27186   arg1 = (Dali::Renderer *)jarg1;
27187   {
27188     try {
27189       result = ((Dali::Renderer const *)arg1)->GetTextures();
27190     } catch (std::out_of_range& e) {
27191       {
27192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27193       };
27194     } catch (std::exception& e) {
27195       {
27196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27197       };
27198     } catch (Dali::DaliException e) {
27199       {
27200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27201       };
27202     } catch (...) {
27203       {
27204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27205       };
27206     }
27207   }
27208
27209   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27210   return jresult;
27211 }
27212
27213
27214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27215   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27216   Dali::Shader *arg2 = 0 ;
27217
27218   arg1 = (Dali::Renderer *)jarg1;
27219   arg2 = (Dali::Shader *)jarg2;
27220   if (!arg2) {
27221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27222     return ;
27223   }
27224   {
27225     try {
27226       (arg1)->SetShader(*arg2);
27227     } catch (std::out_of_range& e) {
27228       {
27229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27230       };
27231     } catch (std::exception& e) {
27232       {
27233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27234       };
27235     } catch (Dali::DaliException e) {
27236       {
27237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27238       };
27239     } catch (...) {
27240       {
27241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27242       };
27243     }
27244   }
27245
27246 }
27247
27248
27249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27250   void * jresult ;
27251   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27252   Dali::Shader result;
27253
27254   arg1 = (Dali::Renderer *)jarg1;
27255   {
27256     try {
27257       result = ((Dali::Renderer const *)arg1)->GetShader();
27258     } catch (std::out_of_range& e) {
27259       {
27260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27261       };
27262     } catch (std::exception& e) {
27263       {
27264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27265       };
27266     } catch (Dali::DaliException e) {
27267       {
27268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27269       };
27270     } catch (...) {
27271       {
27272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27273       };
27274     }
27275   }
27276
27277   jresult = new Dali::Shader((const Dali::Shader &)result);
27278   return jresult;
27279 }
27280
27281
27282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27283   void * jresult ;
27284   Dali::FrameBuffer::Attachment *result = 0 ;
27285
27286   {
27287     try {
27288       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27289     } catch (std::out_of_range& e) {
27290       {
27291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27292       };
27293     } catch (std::exception& e) {
27294       {
27295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27296       };
27297     } catch (Dali::DaliException e) {
27298       {
27299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27300       };
27301     } catch (...) {
27302       {
27303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27304       };
27305     }
27306   }
27307
27308   jresult = (void *)result;
27309   return jresult;
27310 }
27311
27312
27313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27314   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27315
27316   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27317   {
27318     try {
27319       delete arg1;
27320     } catch (std::out_of_range& e) {
27321       {
27322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27323       };
27324     } catch (std::exception& e) {
27325       {
27326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27327       };
27328     } catch (Dali::DaliException e) {
27329       {
27330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27331       };
27332     } catch (...) {
27333       {
27334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27335       };
27336     }
27337   }
27338
27339 }
27340
27341
27342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27343   void * jresult ;
27344   unsigned int arg1 ;
27345   unsigned int arg2 ;
27346   unsigned int arg3 ;
27347   Dali::FrameBuffer result;
27348
27349   arg1 = (unsigned int)jarg1;
27350   arg2 = (unsigned int)jarg2;
27351   arg3 = (unsigned int)jarg3;
27352   {
27353     try {
27354       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27355     } catch (std::out_of_range& e) {
27356       {
27357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27358       };
27359     } catch (std::exception& e) {
27360       {
27361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27362       };
27363     } catch (Dali::DaliException e) {
27364       {
27365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27366       };
27367     } catch (...) {
27368       {
27369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27370       };
27371     }
27372   }
27373
27374   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27375   return jresult;
27376 }
27377
27378
27379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27380   void * jresult ;
27381   Dali::FrameBuffer *result = 0 ;
27382
27383   {
27384     try {
27385       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27386     } catch (std::out_of_range& e) {
27387       {
27388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27389       };
27390     } catch (std::exception& e) {
27391       {
27392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27393       };
27394     } catch (Dali::DaliException e) {
27395       {
27396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27397       };
27398     } catch (...) {
27399       {
27400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27401       };
27402     }
27403   }
27404
27405   jresult = (void *)result;
27406   return jresult;
27407 }
27408
27409
27410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27411   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27412
27413   arg1 = (Dali::FrameBuffer *)jarg1;
27414   {
27415     try {
27416       delete arg1;
27417     } catch (std::out_of_range& e) {
27418       {
27419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27420       };
27421     } catch (std::exception& e) {
27422       {
27423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27424       };
27425     } catch (Dali::DaliException e) {
27426       {
27427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27428       };
27429     } catch (...) {
27430       {
27431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27432       };
27433     }
27434   }
27435
27436 }
27437
27438
27439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27440   void * jresult ;
27441   Dali::FrameBuffer *arg1 = 0 ;
27442   Dali::FrameBuffer *result = 0 ;
27443
27444   arg1 = (Dali::FrameBuffer *)jarg1;
27445   if (!arg1) {
27446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27447     return 0;
27448   }
27449   {
27450     try {
27451       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27452     } catch (std::out_of_range& e) {
27453       {
27454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27455       };
27456     } catch (std::exception& e) {
27457       {
27458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27459       };
27460     } catch (Dali::DaliException e) {
27461       {
27462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27463       };
27464     } catch (...) {
27465       {
27466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27467       };
27468     }
27469   }
27470
27471   jresult = (void *)result;
27472   return jresult;
27473 }
27474
27475
27476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27477   void * jresult ;
27478   Dali::BaseHandle arg1 ;
27479   Dali::BaseHandle *argp1 ;
27480   Dali::FrameBuffer result;
27481
27482   argp1 = (Dali::BaseHandle *)jarg1;
27483   if (!argp1) {
27484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27485     return 0;
27486   }
27487   arg1 = *argp1;
27488   {
27489     try {
27490       result = Dali::FrameBuffer::DownCast(arg1);
27491     } catch (std::out_of_range& e) {
27492       {
27493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27494       };
27495     } catch (std::exception& e) {
27496       {
27497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27498       };
27499     } catch (Dali::DaliException e) {
27500       {
27501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27502       };
27503     } catch (...) {
27504       {
27505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27506       };
27507     }
27508   }
27509
27510   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27511   return jresult;
27512 }
27513
27514
27515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27516   void * jresult ;
27517   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27518   Dali::FrameBuffer *arg2 = 0 ;
27519   Dali::FrameBuffer *result = 0 ;
27520
27521   arg1 = (Dali::FrameBuffer *)jarg1;
27522   arg2 = (Dali::FrameBuffer *)jarg2;
27523   if (!arg2) {
27524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27525     return 0;
27526   }
27527   {
27528     try {
27529       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27530     } catch (std::out_of_range& e) {
27531       {
27532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27533       };
27534     } catch (std::exception& e) {
27535       {
27536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27537       };
27538     } catch (Dali::DaliException e) {
27539       {
27540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27541       };
27542     } catch (...) {
27543       {
27544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27545       };
27546     }
27547   }
27548
27549   jresult = (void *)result;
27550   return jresult;
27551 }
27552
27553
27554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27555   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27556   Dali::Texture *arg2 = 0 ;
27557
27558   arg1 = (Dali::FrameBuffer *)jarg1;
27559   arg2 = (Dali::Texture *)jarg2;
27560   if (!arg2) {
27561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27562     return ;
27563   }
27564   {
27565     try {
27566       (arg1)->AttachColorTexture(*arg2);
27567     } catch (std::out_of_range& e) {
27568       {
27569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27570       };
27571     } catch (std::exception& e) {
27572       {
27573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27574       };
27575     } catch (Dali::DaliException e) {
27576       {
27577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27578       };
27579     } catch (...) {
27580       {
27581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27582       };
27583     }
27584   }
27585
27586 }
27587
27588
27589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27590   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27591   Dali::Texture *arg2 = 0 ;
27592   unsigned int arg3 ;
27593   unsigned int arg4 ;
27594
27595   arg1 = (Dali::FrameBuffer *)jarg1;
27596   arg2 = (Dali::Texture *)jarg2;
27597   if (!arg2) {
27598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27599     return ;
27600   }
27601   arg3 = (unsigned int)jarg3;
27602   arg4 = (unsigned int)jarg4;
27603   {
27604     try {
27605       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27606     } catch (std::out_of_range& e) {
27607       {
27608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27609       };
27610     } catch (std::exception& e) {
27611       {
27612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27613       };
27614     } catch (Dali::DaliException e) {
27615       {
27616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27617       };
27618     } catch (...) {
27619       {
27620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27621       };
27622     }
27623   }
27624
27625 }
27626
27627
27628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27629   void * jresult ;
27630   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27631   Dali::Texture result;
27632
27633   arg1 = (Dali::FrameBuffer *)jarg1;
27634   {
27635     try {
27636       result = (arg1)->GetColorTexture();
27637     } catch (std::out_of_range& e) {
27638       {
27639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27640       };
27641     } catch (std::exception& e) {
27642       {
27643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27644       };
27645     } catch (Dali::DaliException e) {
27646       {
27647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27648       };
27649     } catch (...) {
27650       {
27651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27652       };
27653     }
27654   }
27655
27656   jresult = new Dali::Texture((const Dali::Texture &)result);
27657   return jresult;
27658 }
27659
27660
27661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27662   void * jresult ;
27663   Dali::RenderTaskList *result = 0 ;
27664
27665   {
27666     try {
27667       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27668     } catch (std::out_of_range& e) {
27669       {
27670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27671       };
27672     } catch (std::exception& e) {
27673       {
27674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27675       };
27676     } catch (Dali::DaliException e) {
27677       {
27678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27679       };
27680     } catch (...) {
27681       {
27682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27683       };
27684     }
27685   }
27686
27687   jresult = (void *)result;
27688   return jresult;
27689 }
27690
27691
27692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27693   void * jresult ;
27694   Dali::BaseHandle arg1 ;
27695   Dali::BaseHandle *argp1 ;
27696   Dali::RenderTaskList result;
27697
27698   argp1 = (Dali::BaseHandle *)jarg1;
27699   if (!argp1) {
27700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27701     return 0;
27702   }
27703   arg1 = *argp1;
27704   {
27705     try {
27706       result = Dali::RenderTaskList::DownCast(arg1);
27707     } catch (std::out_of_range& e) {
27708       {
27709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27710       };
27711     } catch (std::exception& e) {
27712       {
27713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27714       };
27715     } catch (Dali::DaliException e) {
27716       {
27717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27718       };
27719     } catch (...) {
27720       {
27721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27722       };
27723     }
27724   }
27725
27726   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27727   return jresult;
27728 }
27729
27730
27731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27732   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27733
27734   arg1 = (Dali::RenderTaskList *)jarg1;
27735   {
27736     try {
27737       delete arg1;
27738     } catch (std::out_of_range& e) {
27739       {
27740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27741       };
27742     } catch (std::exception& e) {
27743       {
27744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27745       };
27746     } catch (Dali::DaliException e) {
27747       {
27748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27749       };
27750     } catch (...) {
27751       {
27752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27753       };
27754     }
27755   }
27756
27757 }
27758
27759
27760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27761   void * jresult ;
27762   Dali::RenderTaskList *arg1 = 0 ;
27763   Dali::RenderTaskList *result = 0 ;
27764
27765   arg1 = (Dali::RenderTaskList *)jarg1;
27766   if (!arg1) {
27767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27768     return 0;
27769   }
27770   {
27771     try {
27772       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27773     } catch (std::out_of_range& e) {
27774       {
27775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27776       };
27777     } catch (std::exception& e) {
27778       {
27779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27780       };
27781     } catch (Dali::DaliException e) {
27782       {
27783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27784       };
27785     } catch (...) {
27786       {
27787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27788       };
27789     }
27790   }
27791
27792   jresult = (void *)result;
27793   return jresult;
27794 }
27795
27796
27797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27798   void * jresult ;
27799   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27800   Dali::RenderTaskList *arg2 = 0 ;
27801   Dali::RenderTaskList *result = 0 ;
27802
27803   arg1 = (Dali::RenderTaskList *)jarg1;
27804   arg2 = (Dali::RenderTaskList *)jarg2;
27805   if (!arg2) {
27806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27807     return 0;
27808   }
27809   {
27810     try {
27811       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27812     } catch (std::out_of_range& e) {
27813       {
27814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27815       };
27816     } catch (std::exception& e) {
27817       {
27818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27819       };
27820     } catch (Dali::DaliException e) {
27821       {
27822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27823       };
27824     } catch (...) {
27825       {
27826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27827       };
27828     }
27829   }
27830
27831   jresult = (void *)result;
27832   return jresult;
27833 }
27834
27835
27836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27837   void * jresult ;
27838   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27839   Dali::RenderTask result;
27840
27841   arg1 = (Dali::RenderTaskList *)jarg1;
27842   {
27843     try {
27844       result = (arg1)->CreateTask();
27845     } catch (std::out_of_range& e) {
27846       {
27847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27848       };
27849     } catch (std::exception& e) {
27850       {
27851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27852       };
27853     } catch (Dali::DaliException e) {
27854       {
27855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27856       };
27857     } catch (...) {
27858       {
27859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27860       };
27861     }
27862   }
27863
27864   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27865   return jresult;
27866 }
27867
27868
27869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27870   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27871   Dali::RenderTask arg2 ;
27872   Dali::RenderTask *argp2 ;
27873
27874   arg1 = (Dali::RenderTaskList *)jarg1;
27875   argp2 = (Dali::RenderTask *)jarg2;
27876   if (!argp2) {
27877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27878     return ;
27879   }
27880   arg2 = *argp2;
27881   {
27882     try {
27883       (arg1)->RemoveTask(arg2);
27884     } catch (std::out_of_range& e) {
27885       {
27886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27887       };
27888     } catch (std::exception& e) {
27889       {
27890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27891       };
27892     } catch (Dali::DaliException e) {
27893       {
27894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27895       };
27896     } catch (...) {
27897       {
27898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27899       };
27900     }
27901   }
27902
27903 }
27904
27905
27906 //// ===============================================end part 1 =================
27907
27908 //// ========================= part 2 ===============================
27909
27910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27911   unsigned int jresult ;
27912   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27913   unsigned int result;
27914
27915   arg1 = (Dali::RenderTaskList *)jarg1;
27916   {
27917     try {
27918       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27919     } catch (std::out_of_range& e) {
27920       {
27921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27922       };
27923     } catch (std::exception& e) {
27924       {
27925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27926       };
27927     } catch (Dali::DaliException e) {
27928       {
27929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27930       };
27931     } catch (...) {
27932       {
27933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27934       };
27935     }
27936   }
27937
27938   jresult = result;
27939   return jresult;
27940 }
27941
27942
27943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27944   void * jresult ;
27945   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27946   unsigned int arg2 ;
27947   Dali::RenderTask result;
27948
27949   arg1 = (Dali::RenderTaskList *)jarg1;
27950   arg2 = (unsigned int)jarg2;
27951   {
27952     try {
27953       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27954     } catch (std::out_of_range& e) {
27955       {
27956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27957       };
27958     } catch (std::exception& e) {
27959       {
27960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27961       };
27962     } catch (Dali::DaliException e) {
27963       {
27964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27965       };
27966     } catch (...) {
27967       {
27968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27969       };
27970     }
27971   }
27972
27973   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27974   return jresult;
27975 }
27976
27977
27978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27979   int jresult ;
27980   int result;
27981
27982   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27983   jresult = (int)result;
27984   return jresult;
27985 }
27986
27987
27988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27989   int jresult ;
27990   int result;
27991
27992   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27993   jresult = (int)result;
27994   return jresult;
27995 }
27996
27997
27998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27999   int jresult ;
28000   int result;
28001
28002   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28003   jresult = (int)result;
28004   return jresult;
28005 }
28006
28007
28008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28009   int jresult ;
28010   int result;
28011
28012   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28013   jresult = (int)result;
28014   return jresult;
28015 }
28016
28017
28018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28019   void * jresult ;
28020   Dali::RenderTask::Property *result = 0 ;
28021
28022   {
28023     try {
28024       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28025     } catch (std::out_of_range& e) {
28026       {
28027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28028       };
28029     } catch (std::exception& e) {
28030       {
28031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28032       };
28033     } catch (Dali::DaliException e) {
28034       {
28035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28036       };
28037     } catch (...) {
28038       {
28039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28040       };
28041     }
28042   }
28043
28044   jresult = (void *)result;
28045   return jresult;
28046 }
28047
28048
28049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28050   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28051
28052   arg1 = (Dali::RenderTask::Property *)jarg1;
28053   {
28054     try {
28055       delete arg1;
28056     } catch (std::out_of_range& e) {
28057       {
28058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28059       };
28060     } catch (std::exception& e) {
28061       {
28062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28063       };
28064     } catch (Dali::DaliException e) {
28065       {
28066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28067       };
28068     } catch (...) {
28069       {
28070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28071       };
28072     }
28073   }
28074
28075 }
28076
28077
28078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28079   void * jresult ;
28080   bool (*result)(Dali::Vector2 &) = 0 ;
28081
28082   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28083   jresult = (void *)result;
28084   return jresult;
28085 }
28086
28087
28088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28089   void * jresult ;
28090   bool (*result)(Dali::Vector2 &) = 0 ;
28091
28092   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28093   jresult = (void *)result;
28094   return jresult;
28095 }
28096
28097
28098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28099   unsigned int jresult ;
28100   bool result;
28101
28102   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28103   jresult = result;
28104   return jresult;
28105 }
28106
28107
28108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28109   unsigned int jresult ;
28110   bool result;
28111
28112   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28113   jresult = result;
28114   return jresult;
28115 }
28116
28117
28118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28119   void * jresult ;
28120   Dali::Vector4 *result = 0 ;
28121
28122   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28123   jresult = (void *)result;
28124   return jresult;
28125 }
28126
28127
28128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28129   unsigned int jresult ;
28130   bool result;
28131
28132   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28133   jresult = result;
28134   return jresult;
28135 }
28136
28137
28138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28139   unsigned int jresult ;
28140   bool result;
28141
28142   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28143   jresult = result;
28144   return jresult;
28145 }
28146
28147
28148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28149   unsigned int jresult ;
28150   unsigned int result;
28151
28152   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28153   jresult = result;
28154   return jresult;
28155 }
28156
28157
28158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28159   void * jresult ;
28160   Dali::RenderTask *result = 0 ;
28161
28162   {
28163     try {
28164       result = (Dali::RenderTask *)new Dali::RenderTask();
28165     } catch (std::out_of_range& e) {
28166       {
28167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28168       };
28169     } catch (std::exception& e) {
28170       {
28171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28172       };
28173     } catch (Dali::DaliException e) {
28174       {
28175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28176       };
28177     } catch (...) {
28178       {
28179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28180       };
28181     }
28182   }
28183
28184   jresult = (void *)result;
28185   return jresult;
28186 }
28187
28188
28189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28190   void * jresult ;
28191   Dali::BaseHandle arg1 ;
28192   Dali::BaseHandle *argp1 ;
28193   Dali::RenderTask result;
28194
28195   argp1 = (Dali::BaseHandle *)jarg1;
28196   if (!argp1) {
28197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28198     return 0;
28199   }
28200   arg1 = *argp1;
28201   {
28202     try {
28203       result = Dali::RenderTask::DownCast(arg1);
28204     } catch (std::out_of_range& e) {
28205       {
28206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28207       };
28208     } catch (std::exception& e) {
28209       {
28210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28211       };
28212     } catch (Dali::DaliException e) {
28213       {
28214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28215       };
28216     } catch (...) {
28217       {
28218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28219       };
28220     }
28221   }
28222
28223   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28224   return jresult;
28225 }
28226
28227
28228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28229   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28230
28231   arg1 = (Dali::RenderTask *)jarg1;
28232   {
28233     try {
28234       delete arg1;
28235     } catch (std::out_of_range& e) {
28236       {
28237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28238       };
28239     } catch (std::exception& e) {
28240       {
28241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28242       };
28243     } catch (Dali::DaliException e) {
28244       {
28245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28246       };
28247     } catch (...) {
28248       {
28249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28250       };
28251     }
28252   }
28253
28254 }
28255
28256
28257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28258   void * jresult ;
28259   Dali::RenderTask *arg1 = 0 ;
28260   Dali::RenderTask *result = 0 ;
28261
28262   arg1 = (Dali::RenderTask *)jarg1;
28263   if (!arg1) {
28264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28265     return 0;
28266   }
28267   {
28268     try {
28269       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28270     } catch (std::out_of_range& e) {
28271       {
28272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28273       };
28274     } catch (std::exception& e) {
28275       {
28276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28277       };
28278     } catch (Dali::DaliException e) {
28279       {
28280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28281       };
28282     } catch (...) {
28283       {
28284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28285       };
28286     }
28287   }
28288
28289   jresult = (void *)result;
28290   return jresult;
28291 }
28292
28293
28294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28295   void * jresult ;
28296   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28297   Dali::RenderTask *arg2 = 0 ;
28298   Dali::RenderTask *result = 0 ;
28299
28300   arg1 = (Dali::RenderTask *)jarg1;
28301   arg2 = (Dali::RenderTask *)jarg2;
28302   if (!arg2) {
28303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28304     return 0;
28305   }
28306   {
28307     try {
28308       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28309     } catch (std::out_of_range& e) {
28310       {
28311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28312       };
28313     } catch (std::exception& e) {
28314       {
28315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28316       };
28317     } catch (Dali::DaliException e) {
28318       {
28319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28320       };
28321     } catch (...) {
28322       {
28323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28324       };
28325     }
28326   }
28327
28328   jresult = (void *)result;
28329   return jresult;
28330 }
28331
28332
28333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28334   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28335   Dali::Actor arg2 ;
28336   Dali::Actor *argp2 ;
28337
28338   arg1 = (Dali::RenderTask *)jarg1;
28339   argp2 = (Dali::Actor *)jarg2;
28340   if (!argp2) {
28341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28342     return ;
28343   }
28344   arg2 = *argp2;
28345   {
28346     try {
28347       (arg1)->SetSourceActor(arg2);
28348     } catch (std::out_of_range& e) {
28349       {
28350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28351       };
28352     } catch (std::exception& e) {
28353       {
28354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28355       };
28356     } catch (Dali::DaliException e) {
28357       {
28358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28359       };
28360     } catch (...) {
28361       {
28362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28363       };
28364     }
28365   }
28366
28367 }
28368
28369
28370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28371   void * jresult ;
28372   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28373   Dali::Actor result;
28374
28375   arg1 = (Dali::RenderTask *)jarg1;
28376   {
28377     try {
28378       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28379     } catch (std::out_of_range& e) {
28380       {
28381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28382       };
28383     } catch (std::exception& e) {
28384       {
28385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28386       };
28387     } catch (Dali::DaliException e) {
28388       {
28389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28390       };
28391     } catch (...) {
28392       {
28393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28394       };
28395     }
28396   }
28397
28398   jresult = new Dali::Actor((const Dali::Actor &)result);
28399   return jresult;
28400 }
28401
28402
28403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28404   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28405   bool arg2 ;
28406
28407   arg1 = (Dali::RenderTask *)jarg1;
28408   arg2 = jarg2 ? true : false;
28409   {
28410     try {
28411       (arg1)->SetExclusive(arg2);
28412     } catch (std::out_of_range& e) {
28413       {
28414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28415       };
28416     } catch (std::exception& e) {
28417       {
28418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28419       };
28420     } catch (Dali::DaliException e) {
28421       {
28422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28423       };
28424     } catch (...) {
28425       {
28426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28427       };
28428     }
28429   }
28430
28431 }
28432
28433
28434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28435   unsigned int jresult ;
28436   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28437   bool result;
28438
28439   arg1 = (Dali::RenderTask *)jarg1;
28440   {
28441     try {
28442       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28443     } catch (std::out_of_range& e) {
28444       {
28445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28446       };
28447     } catch (std::exception& e) {
28448       {
28449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28450       };
28451     } catch (Dali::DaliException e) {
28452       {
28453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28454       };
28455     } catch (...) {
28456       {
28457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28458       };
28459     }
28460   }
28461
28462   jresult = result;
28463   return jresult;
28464 }
28465
28466
28467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28468   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28469   bool arg2 ;
28470
28471   arg1 = (Dali::RenderTask *)jarg1;
28472   arg2 = jarg2 ? true : false;
28473   {
28474     try {
28475       (arg1)->SetInputEnabled(arg2);
28476     } catch (std::out_of_range& e) {
28477       {
28478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28479       };
28480     } catch (std::exception& e) {
28481       {
28482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28483       };
28484     } catch (Dali::DaliException e) {
28485       {
28486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28487       };
28488     } catch (...) {
28489       {
28490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28491       };
28492     }
28493   }
28494
28495 }
28496
28497
28498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28499   unsigned int jresult ;
28500   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28501   bool result;
28502
28503   arg1 = (Dali::RenderTask *)jarg1;
28504   {
28505     try {
28506       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28507     } catch (std::out_of_range& e) {
28508       {
28509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28510       };
28511     } catch (std::exception& e) {
28512       {
28513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28514       };
28515     } catch (Dali::DaliException e) {
28516       {
28517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28518       };
28519     } catch (...) {
28520       {
28521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28522       };
28523     }
28524   }
28525
28526   jresult = result;
28527   return jresult;
28528 }
28529
28530
28531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28532   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28533   Dali::CameraActor arg2 ;
28534   Dali::CameraActor *argp2 ;
28535
28536   arg1 = (Dali::RenderTask *)jarg1;
28537   argp2 = (Dali::CameraActor *)jarg2;
28538   if (!argp2) {
28539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28540     return ;
28541   }
28542   arg2 = *argp2;
28543   {
28544     try {
28545       (arg1)->SetCameraActor(arg2);
28546     } catch (std::out_of_range& e) {
28547       {
28548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28549       };
28550     } catch (std::exception& e) {
28551       {
28552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28553       };
28554     } catch (Dali::DaliException e) {
28555       {
28556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28557       };
28558     } catch (...) {
28559       {
28560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28561       };
28562     }
28563   }
28564
28565 }
28566
28567
28568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28569   void * jresult ;
28570   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28571   Dali::CameraActor result;
28572
28573   arg1 = (Dali::RenderTask *)jarg1;
28574   {
28575     try {
28576       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28577     } catch (std::out_of_range& e) {
28578       {
28579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28580       };
28581     } catch (std::exception& e) {
28582       {
28583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28584       };
28585     } catch (Dali::DaliException e) {
28586       {
28587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28588       };
28589     } catch (...) {
28590       {
28591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28592       };
28593     }
28594   }
28595
28596   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28597   return jresult;
28598 }
28599
28600
28601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28602   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28603   Dali::FrameBufferImage arg2 ;
28604   Dali::FrameBufferImage *argp2 ;
28605
28606   arg1 = (Dali::RenderTask *)jarg1;
28607   argp2 = (Dali::FrameBufferImage *)jarg2;
28608   if (!argp2) {
28609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28610     return ;
28611   }
28612   arg2 = *argp2;
28613   {
28614     try {
28615       (arg1)->SetTargetFrameBuffer(arg2);
28616     } catch (std::out_of_range& e) {
28617       {
28618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28619       };
28620     } catch (std::exception& e) {
28621       {
28622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28623       };
28624     } catch (Dali::DaliException e) {
28625       {
28626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28627       };
28628     } catch (...) {
28629       {
28630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28631       };
28632     }
28633   }
28634
28635 }
28636
28637
28638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28639   void * jresult ;
28640   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28641   Dali::FrameBufferImage result;
28642
28643   arg1 = (Dali::RenderTask *)jarg1;
28644   {
28645     try {
28646       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28647     } catch (std::out_of_range& e) {
28648       {
28649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28650       };
28651     } catch (std::exception& e) {
28652       {
28653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28654       };
28655     } catch (Dali::DaliException e) {
28656       {
28657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28658       };
28659     } catch (...) {
28660       {
28661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28662       };
28663     }
28664   }
28665
28666   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28667   return jresult;
28668 }
28669
28670
28671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28672   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28673   Dali::FrameBuffer arg2 ;
28674   Dali::FrameBuffer *argp2 ;
28675
28676   arg1 = (Dali::RenderTask *)jarg1;
28677   argp2 = (Dali::FrameBuffer *)jarg2;
28678   if (!argp2) {
28679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28680     return ;
28681   }
28682   arg2 = *argp2;
28683   {
28684     try {
28685       (arg1)->SetFrameBuffer(arg2);
28686     } catch (std::out_of_range& e) {
28687       {
28688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28689       };
28690     } catch (std::exception& e) {
28691       {
28692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28693       };
28694     } catch (Dali::DaliException e) {
28695       {
28696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28697       };
28698     } catch (...) {
28699       {
28700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28701       };
28702     }
28703   }
28704
28705 }
28706
28707
28708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28709   void * jresult ;
28710   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28711   Dali::FrameBuffer result;
28712
28713   arg1 = (Dali::RenderTask *)jarg1;
28714   {
28715     try {
28716       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28717     } catch (std::out_of_range& e) {
28718       {
28719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28720       };
28721     } catch (std::exception& e) {
28722       {
28723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28724       };
28725     } catch (Dali::DaliException e) {
28726       {
28727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28728       };
28729     } catch (...) {
28730       {
28731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28732       };
28733     }
28734   }
28735
28736   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28737   return jresult;
28738 }
28739
28740
28741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28742   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28743   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28744
28745   arg1 = (Dali::RenderTask *)jarg1;
28746   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28747   {
28748     try {
28749       (arg1)->SetScreenToFrameBufferFunction(arg2);
28750     } catch (std::out_of_range& e) {
28751       {
28752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28753       };
28754     } catch (std::exception& e) {
28755       {
28756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28757       };
28758     } catch (Dali::DaliException e) {
28759       {
28760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28761       };
28762     } catch (...) {
28763       {
28764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28765       };
28766     }
28767   }
28768
28769 }
28770
28771
28772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28773   void * jresult ;
28774   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28775   Dali::RenderTask::ScreenToFrameBufferFunction result;
28776
28777   arg1 = (Dali::RenderTask *)jarg1;
28778   {
28779     try {
28780       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28781     } catch (std::out_of_range& e) {
28782       {
28783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28784       };
28785     } catch (std::exception& e) {
28786       {
28787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28788       };
28789     } catch (Dali::DaliException e) {
28790       {
28791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28792       };
28793     } catch (...) {
28794       {
28795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28796       };
28797     }
28798   }
28799
28800   jresult = (void *)result;
28801   return jresult;
28802 }
28803
28804
28805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28806   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28807   Dali::Actor arg2 ;
28808   Dali::Actor *argp2 ;
28809
28810   arg1 = (Dali::RenderTask *)jarg1;
28811   argp2 = (Dali::Actor *)jarg2;
28812   if (!argp2) {
28813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28814     return ;
28815   }
28816   arg2 = *argp2;
28817   {
28818     try {
28819       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28820     } catch (std::out_of_range& e) {
28821       {
28822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28823       };
28824     } catch (std::exception& e) {
28825       {
28826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28827       };
28828     } catch (Dali::DaliException e) {
28829       {
28830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28831       };
28832     } catch (...) {
28833       {
28834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28835       };
28836     }
28837   }
28838
28839 }
28840
28841
28842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28843   void * jresult ;
28844   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28845   Dali::Actor result;
28846
28847   arg1 = (Dali::RenderTask *)jarg1;
28848   {
28849     try {
28850       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28851     } catch (std::out_of_range& e) {
28852       {
28853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28854       };
28855     } catch (std::exception& e) {
28856       {
28857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28858       };
28859     } catch (Dali::DaliException e) {
28860       {
28861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28862       };
28863     } catch (...) {
28864       {
28865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28866       };
28867     }
28868   }
28869
28870   jresult = new Dali::Actor((const Dali::Actor &)result);
28871   return jresult;
28872 }
28873
28874
28875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28876   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28877   Dali::Vector2 arg2 ;
28878   Dali::Vector2 *argp2 ;
28879
28880   arg1 = (Dali::RenderTask *)jarg1;
28881   argp2 = (Dali::Vector2 *)jarg2;
28882   if (!argp2) {
28883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28884     return ;
28885   }
28886   arg2 = *argp2;
28887   {
28888     try {
28889       (arg1)->SetViewportPosition(arg2);
28890     } catch (std::out_of_range& e) {
28891       {
28892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28893       };
28894     } catch (std::exception& e) {
28895       {
28896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28897       };
28898     } catch (Dali::DaliException e) {
28899       {
28900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28901       };
28902     } catch (...) {
28903       {
28904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28905       };
28906     }
28907   }
28908
28909 }
28910
28911
28912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28913   void * jresult ;
28914   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28915   Dali::Vector2 result;
28916
28917   arg1 = (Dali::RenderTask *)jarg1;
28918   {
28919     try {
28920       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28921     } catch (std::out_of_range& e) {
28922       {
28923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28924       };
28925     } catch (std::exception& e) {
28926       {
28927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28928       };
28929     } catch (Dali::DaliException e) {
28930       {
28931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28932       };
28933     } catch (...) {
28934       {
28935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28936       };
28937     }
28938   }
28939
28940   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28941   return jresult;
28942 }
28943
28944
28945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28946   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28947   Dali::Vector2 arg2 ;
28948   Dali::Vector2 *argp2 ;
28949
28950   arg1 = (Dali::RenderTask *)jarg1;
28951   argp2 = (Dali::Vector2 *)jarg2;
28952   if (!argp2) {
28953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28954     return ;
28955   }
28956   arg2 = *argp2;
28957   {
28958     try {
28959       (arg1)->SetViewportSize(arg2);
28960     } catch (std::out_of_range& e) {
28961       {
28962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28963       };
28964     } catch (std::exception& e) {
28965       {
28966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28967       };
28968     } catch (Dali::DaliException e) {
28969       {
28970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28971       };
28972     } catch (...) {
28973       {
28974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28975       };
28976     }
28977   }
28978
28979 }
28980
28981
28982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28983   void * jresult ;
28984   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28985   Dali::Vector2 result;
28986
28987   arg1 = (Dali::RenderTask *)jarg1;
28988   {
28989     try {
28990       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28991     } catch (std::out_of_range& e) {
28992       {
28993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28994       };
28995     } catch (std::exception& e) {
28996       {
28997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28998       };
28999     } catch (Dali::DaliException e) {
29000       {
29001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29002       };
29003     } catch (...) {
29004       {
29005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29006       };
29007     }
29008   }
29009
29010   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29011   return jresult;
29012 }
29013
29014
29015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29016   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29017   Dali::Viewport arg2 ;
29018   Dali::Viewport *argp2 ;
29019
29020   arg1 = (Dali::RenderTask *)jarg1;
29021   argp2 = (Dali::Viewport *)jarg2;
29022   if (!argp2) {
29023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29024     return ;
29025   }
29026   arg2 = *argp2;
29027   {
29028     try {
29029       (arg1)->SetViewport(arg2);
29030     } catch (std::out_of_range& e) {
29031       {
29032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29033       };
29034     } catch (std::exception& e) {
29035       {
29036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29037       };
29038     } catch (Dali::DaliException e) {
29039       {
29040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29041       };
29042     } catch (...) {
29043       {
29044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29045       };
29046     }
29047   }
29048
29049 }
29050
29051
29052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29053   void * jresult ;
29054   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29055   Dali::Viewport result;
29056
29057   arg1 = (Dali::RenderTask *)jarg1;
29058   {
29059     try {
29060       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29061     } catch (std::out_of_range& e) {
29062       {
29063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29064       };
29065     } catch (std::exception& e) {
29066       {
29067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29068       };
29069     } catch (Dali::DaliException e) {
29070       {
29071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29072       };
29073     } catch (...) {
29074       {
29075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29076       };
29077     }
29078   }
29079
29080   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29081   return jresult;
29082 }
29083
29084
29085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29086   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29087   Dali::Vector4 *arg2 = 0 ;
29088
29089   arg1 = (Dali::RenderTask *)jarg1;
29090   arg2 = (Dali::Vector4 *)jarg2;
29091   if (!arg2) {
29092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29093     return ;
29094   }
29095   {
29096     try {
29097       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29098     } catch (std::out_of_range& e) {
29099       {
29100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29101       };
29102     } catch (std::exception& e) {
29103       {
29104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29105       };
29106     } catch (Dali::DaliException e) {
29107       {
29108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29109       };
29110     } catch (...) {
29111       {
29112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29113       };
29114     }
29115   }
29116
29117 }
29118
29119
29120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29121   void * jresult ;
29122   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29123   Dali::Vector4 result;
29124
29125   arg1 = (Dali::RenderTask *)jarg1;
29126   {
29127     try {
29128       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29129     } catch (std::out_of_range& e) {
29130       {
29131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29132       };
29133     } catch (std::exception& e) {
29134       {
29135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29136       };
29137     } catch (Dali::DaliException e) {
29138       {
29139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29140       };
29141     } catch (...) {
29142       {
29143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29144       };
29145     }
29146   }
29147
29148   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29149   return jresult;
29150 }
29151
29152
29153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29154   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29155   bool arg2 ;
29156
29157   arg1 = (Dali::RenderTask *)jarg1;
29158   arg2 = jarg2 ? true : false;
29159   {
29160     try {
29161       (arg1)->SetClearEnabled(arg2);
29162     } catch (std::out_of_range& e) {
29163       {
29164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29165       };
29166     } catch (std::exception& e) {
29167       {
29168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29169       };
29170     } catch (Dali::DaliException e) {
29171       {
29172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29173       };
29174     } catch (...) {
29175       {
29176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29177       };
29178     }
29179   }
29180
29181 }
29182
29183
29184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29185   unsigned int jresult ;
29186   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29187   bool result;
29188
29189   arg1 = (Dali::RenderTask *)jarg1;
29190   {
29191     try {
29192       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29193     } catch (std::out_of_range& e) {
29194       {
29195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29196       };
29197     } catch (std::exception& e) {
29198       {
29199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29200       };
29201     } catch (Dali::DaliException e) {
29202       {
29203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29204       };
29205     } catch (...) {
29206       {
29207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29208       };
29209     }
29210   }
29211
29212   jresult = result;
29213   return jresult;
29214 }
29215
29216
29217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29218   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29219   bool arg2 ;
29220
29221   arg1 = (Dali::RenderTask *)jarg1;
29222   arg2 = jarg2 ? true : false;
29223   {
29224     try {
29225       (arg1)->SetCullMode(arg2);
29226     } catch (std::out_of_range& e) {
29227       {
29228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29229       };
29230     } catch (std::exception& e) {
29231       {
29232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29233       };
29234     } catch (Dali::DaliException e) {
29235       {
29236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29237       };
29238     } catch (...) {
29239       {
29240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29241       };
29242     }
29243   }
29244
29245 }
29246
29247
29248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29249   unsigned int jresult ;
29250   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29251   bool result;
29252
29253   arg1 = (Dali::RenderTask *)jarg1;
29254   {
29255     try {
29256       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29257     } catch (std::out_of_range& e) {
29258       {
29259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29260       };
29261     } catch (std::exception& e) {
29262       {
29263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29264       };
29265     } catch (Dali::DaliException e) {
29266       {
29267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29268       };
29269     } catch (...) {
29270       {
29271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29272       };
29273     }
29274   }
29275
29276   jresult = result;
29277   return jresult;
29278 }
29279
29280
29281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29282   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29283   unsigned int arg2 ;
29284
29285   arg1 = (Dali::RenderTask *)jarg1;
29286   arg2 = (unsigned int)jarg2;
29287   {
29288     try {
29289       (arg1)->SetRefreshRate(arg2);
29290     } catch (std::out_of_range& e) {
29291       {
29292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29293       };
29294     } catch (std::exception& e) {
29295       {
29296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29297       };
29298     } catch (Dali::DaliException e) {
29299       {
29300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29301       };
29302     } catch (...) {
29303       {
29304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29305       };
29306     }
29307   }
29308
29309 }
29310
29311
29312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29313   unsigned int jresult ;
29314   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29315   unsigned int result;
29316
29317   arg1 = (Dali::RenderTask *)jarg1;
29318   {
29319     try {
29320       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29321     } catch (std::out_of_range& e) {
29322       {
29323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29324       };
29325     } catch (std::exception& e) {
29326       {
29327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29328       };
29329     } catch (Dali::DaliException e) {
29330       {
29331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29332       };
29333     } catch (...) {
29334       {
29335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29336       };
29337     }
29338   }
29339
29340   jresult = result;
29341   return jresult;
29342 }
29343
29344
29345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29346   unsigned int jresult ;
29347   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29348   Dali::Vector3 *arg2 = 0 ;
29349   float *arg3 = 0 ;
29350   float *arg4 = 0 ;
29351   bool result;
29352
29353   arg1 = (Dali::RenderTask *)jarg1;
29354   arg2 = (Dali::Vector3 *)jarg2;
29355   if (!arg2) {
29356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29357     return 0;
29358   }
29359   arg3 = (float *)jarg3;
29360   arg4 = (float *)jarg4;
29361   {
29362     try {
29363       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29364     } catch (std::out_of_range& e) {
29365       {
29366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29367       };
29368     } catch (std::exception& e) {
29369       {
29370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29371       };
29372     } catch (Dali::DaliException e) {
29373       {
29374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29375       };
29376     } catch (...) {
29377       {
29378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29379       };
29380     }
29381   }
29382
29383   jresult = result;
29384   return jresult;
29385 }
29386
29387
29388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29389   unsigned int jresult ;
29390   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29391   Dali::Actor arg2 ;
29392   float arg3 ;
29393   float arg4 ;
29394   float *arg5 = 0 ;
29395   float *arg6 = 0 ;
29396   Dali::Actor *argp2 ;
29397   bool result;
29398
29399   arg1 = (Dali::RenderTask *)jarg1;
29400   argp2 = (Dali::Actor *)jarg2;
29401   if (!argp2) {
29402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29403     return 0;
29404   }
29405   arg2 = *argp2;
29406   arg3 = (float)jarg3;
29407   arg4 = (float)jarg4;
29408   arg5 = (float *)jarg5;
29409   arg6 = (float *)jarg6;
29410   {
29411     try {
29412       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29413     } catch (std::out_of_range& e) {
29414       {
29415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29416       };
29417     } catch (std::exception& e) {
29418       {
29419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29420       };
29421     } catch (Dali::DaliException e) {
29422       {
29423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29424       };
29425     } catch (...) {
29426       {
29427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29428       };
29429     }
29430   }
29431
29432   jresult = result;
29433   return jresult;
29434 }
29435
29436
29437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29438   void * jresult ;
29439   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29440   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29441
29442   arg1 = (Dali::RenderTask *)jarg1;
29443   {
29444     try {
29445       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29446     } catch (std::out_of_range& e) {
29447       {
29448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29449       };
29450     } catch (std::exception& e) {
29451       {
29452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29453       };
29454     } catch (Dali::DaliException e) {
29455       {
29456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29457       };
29458     } catch (...) {
29459       {
29460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29461       };
29462     }
29463   }
29464
29465   jresult = (void *)result;
29466   return jresult;
29467 }
29468
29469
29470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29471   void * jresult ;
29472   int arg1 ;
29473   Dali::TouchPoint::State arg2 ;
29474   float arg3 ;
29475   float arg4 ;
29476   Dali::TouchPoint *result = 0 ;
29477
29478   arg1 = (int)jarg1;
29479   arg2 = (Dali::TouchPoint::State)jarg2;
29480   arg3 = (float)jarg3;
29481   arg4 = (float)jarg4;
29482   {
29483     try {
29484       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29485     } catch (std::out_of_range& e) {
29486       {
29487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29488       };
29489     } catch (std::exception& e) {
29490       {
29491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29492       };
29493     } catch (Dali::DaliException e) {
29494       {
29495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29496       };
29497     } catch (...) {
29498       {
29499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29500       };
29501     }
29502   }
29503
29504   jresult = (void *)result;
29505   return jresult;
29506 }
29507
29508
29509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29510   void * jresult ;
29511   int arg1 ;
29512   Dali::TouchPoint::State arg2 ;
29513   float arg3 ;
29514   float arg4 ;
29515   float arg5 ;
29516   float arg6 ;
29517   Dali::TouchPoint *result = 0 ;
29518
29519   arg1 = (int)jarg1;
29520   arg2 = (Dali::TouchPoint::State)jarg2;
29521   arg3 = (float)jarg3;
29522   arg4 = (float)jarg4;
29523   arg5 = (float)jarg5;
29524   arg6 = (float)jarg6;
29525   {
29526     try {
29527       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29528     } catch (std::out_of_range& e) {
29529       {
29530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29531       };
29532     } catch (std::exception& e) {
29533       {
29534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29535       };
29536     } catch (Dali::DaliException e) {
29537       {
29538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29539       };
29540     } catch (...) {
29541       {
29542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29543       };
29544     }
29545   }
29546
29547   jresult = (void *)result;
29548   return jresult;
29549 }
29550
29551
29552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29553   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29554
29555   arg1 = (Dali::TouchPoint *)jarg1;
29556   {
29557     try {
29558       delete arg1;
29559     } catch (std::out_of_range& e) {
29560       {
29561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29562       };
29563     } catch (std::exception& e) {
29564       {
29565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29566       };
29567     } catch (Dali::DaliException e) {
29568       {
29569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29570       };
29571     } catch (...) {
29572       {
29573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29574       };
29575     }
29576   }
29577
29578 }
29579
29580
29581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29582   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29583   int arg2 ;
29584
29585   arg1 = (Dali::TouchPoint *)jarg1;
29586   arg2 = (int)jarg2;
29587   if (arg1) (arg1)->deviceId = arg2;
29588 }
29589
29590
29591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29592   int jresult ;
29593   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29594   int result;
29595
29596   arg1 = (Dali::TouchPoint *)jarg1;
29597   result = (int) ((arg1)->deviceId);
29598   jresult = result;
29599   return jresult;
29600 }
29601
29602
29603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29604   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29605   Dali::TouchPoint::State arg2 ;
29606
29607   arg1 = (Dali::TouchPoint *)jarg1;
29608   arg2 = (Dali::TouchPoint::State)jarg2;
29609   if (arg1) (arg1)->state = arg2;
29610 }
29611
29612
29613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29614   int jresult ;
29615   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29616   Dali::TouchPoint::State result;
29617
29618   arg1 = (Dali::TouchPoint *)jarg1;
29619   result = (Dali::TouchPoint::State) ((arg1)->state);
29620   jresult = (int)result;
29621   return jresult;
29622 }
29623
29624
29625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29626   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29627   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29628
29629   arg1 = (Dali::TouchPoint *)jarg1;
29630   arg2 = (Dali::Actor *)jarg2;
29631   if (arg1) (arg1)->hitActor = *arg2;
29632 }
29633
29634
29635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29636   void * jresult ;
29637   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29638   Dali::Actor *result = 0 ;
29639
29640   arg1 = (Dali::TouchPoint *)jarg1;
29641   result = (Dali::Actor *)& ((arg1)->hitActor);
29642   jresult = (void *)result;
29643   return jresult;
29644 }
29645
29646
29647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29648   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29649   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29650
29651   arg1 = (Dali::TouchPoint *)jarg1;
29652   arg2 = (Dali::Vector2 *)jarg2;
29653   if (arg1) (arg1)->local = *arg2;
29654 }
29655
29656
29657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29658   void * jresult ;
29659   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29660   Dali::Vector2 *result = 0 ;
29661
29662   arg1 = (Dali::TouchPoint *)jarg1;
29663   result = (Dali::Vector2 *)& ((arg1)->local);
29664   jresult = (void *)result;
29665   return jresult;
29666 }
29667
29668
29669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29670   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29671   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29672
29673   arg1 = (Dali::TouchPoint *)jarg1;
29674   arg2 = (Dali::Vector2 *)jarg2;
29675   if (arg1) (arg1)->screen = *arg2;
29676 }
29677
29678
29679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29680   void * jresult ;
29681   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29682   Dali::Vector2 *result = 0 ;
29683
29684   arg1 = (Dali::TouchPoint *)jarg1;
29685   result = (Dali::Vector2 *)& ((arg1)->screen);
29686   jresult = (void *)result;
29687   return jresult;
29688 }
29689
29690
29691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29692   void * jresult ;
29693   Dali::TouchData *result = 0 ;
29694
29695   {
29696     try {
29697       result = (Dali::TouchData *)new Dali::TouchData();
29698     } catch (std::out_of_range& e) {
29699       {
29700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29701       };
29702     } catch (std::exception& e) {
29703       {
29704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29705       };
29706     } catch (Dali::DaliException e) {
29707       {
29708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29709       };
29710     } catch (...) {
29711       {
29712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29713       };
29714     }
29715   }
29716
29717   jresult = (void *)result;
29718   return jresult;
29719 }
29720
29721
29722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29723   void * jresult ;
29724   Dali::TouchData *arg1 = 0 ;
29725   Dali::TouchData *result = 0 ;
29726
29727   arg1 = (Dali::TouchData *)jarg1;
29728   if (!arg1) {
29729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29730     return 0;
29731   }
29732   {
29733     try {
29734       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29735     } catch (std::out_of_range& e) {
29736       {
29737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29738       };
29739     } catch (std::exception& e) {
29740       {
29741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29742       };
29743     } catch (Dali::DaliException e) {
29744       {
29745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29746       };
29747     } catch (...) {
29748       {
29749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29750       };
29751     }
29752   }
29753
29754   jresult = (void *)result;
29755   return jresult;
29756 }
29757
29758
29759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29760   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29761
29762   arg1 = (Dali::TouchData *)jarg1;
29763   {
29764     try {
29765       delete arg1;
29766     } catch (std::out_of_range& e) {
29767       {
29768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29769       };
29770     } catch (std::exception& e) {
29771       {
29772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29773       };
29774     } catch (Dali::DaliException e) {
29775       {
29776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29777       };
29778     } catch (...) {
29779       {
29780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29781       };
29782     }
29783   }
29784
29785 }
29786
29787
29788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29789   void * jresult ;
29790   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29791   Dali::TouchData *arg2 = 0 ;
29792   Dali::TouchData *result = 0 ;
29793
29794   arg1 = (Dali::TouchData *)jarg1;
29795   arg2 = (Dali::TouchData *)jarg2;
29796   if (!arg2) {
29797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29798     return 0;
29799   }
29800   {
29801     try {
29802       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29803     } catch (std::out_of_range& e) {
29804       {
29805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29806       };
29807     } catch (std::exception& e) {
29808       {
29809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29810       };
29811     } catch (Dali::DaliException e) {
29812       {
29813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29814       };
29815     } catch (...) {
29816       {
29817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29818       };
29819     }
29820   }
29821
29822   jresult = (void *)result;
29823   return jresult;
29824 }
29825
29826
29827 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29828   unsigned long jresult ;
29829   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29830   unsigned long result;
29831
29832   arg1 = (Dali::TouchData *)jarg1;
29833   {
29834     try {
29835       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29836     } catch (std::out_of_range& e) {
29837       {
29838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29839       };
29840     } catch (std::exception& e) {
29841       {
29842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29843       };
29844     } catch (Dali::DaliException e) {
29845       {
29846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29847       };
29848     } catch (...) {
29849       {
29850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29851       };
29852     }
29853   }
29854
29855   jresult = (unsigned long)result;
29856   return jresult;
29857 }
29858
29859
29860 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29861   unsigned long jresult ;
29862   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29863   std::size_t result;
29864
29865   arg1 = (Dali::TouchData *)jarg1;
29866   {
29867     try {
29868       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29869     } catch (std::out_of_range& e) {
29870       {
29871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29872       };
29873     } catch (std::exception& e) {
29874       {
29875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29876       };
29877     } catch (Dali::DaliException e) {
29878       {
29879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29880       };
29881     } catch (...) {
29882       {
29883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29884       };
29885     }
29886   }
29887
29888   jresult = (unsigned long)result;
29889   return jresult;
29890 }
29891
29892
29893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29894   int jresult ;
29895   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29896   std::size_t arg2 ;
29897   int32_t result;
29898
29899   arg1 = (Dali::TouchData *)jarg1;
29900   arg2 = (std::size_t)jarg2;
29901   {
29902     try {
29903       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29904     } catch (std::out_of_range& e) {
29905       {
29906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29907       };
29908     } catch (std::exception& e) {
29909       {
29910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29911       };
29912     } catch (Dali::DaliException e) {
29913       {
29914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29915       };
29916     } catch (...) {
29917       {
29918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29919       };
29920     }
29921   }
29922
29923   jresult = result;
29924   return jresult;
29925 }
29926
29927
29928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29929   int jresult ;
29930   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29931   std::size_t arg2 ;
29932   Dali::PointState::Type result;
29933
29934   arg1 = (Dali::TouchData *)jarg1;
29935   arg2 = (std::size_t)jarg2;
29936   {
29937     try {
29938       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29939     } catch (std::out_of_range& e) {
29940       {
29941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29942       };
29943     } catch (std::exception& e) {
29944       {
29945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29946       };
29947     } catch (Dali::DaliException e) {
29948       {
29949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29950       };
29951     } catch (...) {
29952       {
29953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29954       };
29955     }
29956   }
29957
29958   jresult = (int)result;
29959   return jresult;
29960 }
29961
29962
29963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29964   void * jresult ;
29965   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29966   std::size_t arg2 ;
29967   Dali::Actor result;
29968
29969   arg1 = (Dali::TouchData *)jarg1;
29970   arg2 = (std::size_t)jarg2;
29971   {
29972     try {
29973       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29974     } catch (std::out_of_range& e) {
29975       {
29976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29977       };
29978     } catch (std::exception& e) {
29979       {
29980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29981       };
29982     } catch (Dali::DaliException e) {
29983       {
29984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29985       };
29986     } catch (...) {
29987       {
29988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29989       };
29990     }
29991   }
29992
29993   jresult = new Dali::Actor((const Dali::Actor &)result);
29994   return jresult;
29995 }
29996
29997
29998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29999   void * jresult ;
30000   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30001   std::size_t arg2 ;
30002   Dali::Vector2 *result = 0 ;
30003
30004   arg1 = (Dali::TouchData *)jarg1;
30005   arg2 = (std::size_t)jarg2;
30006   {
30007     try {
30008       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30009     } catch (std::out_of_range& e) {
30010       {
30011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30012       };
30013     } catch (std::exception& e) {
30014       {
30015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30016       };
30017     } catch (Dali::DaliException e) {
30018       {
30019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30020       };
30021     } catch (...) {
30022       {
30023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30024       };
30025     }
30026   }
30027
30028   jresult = (void *)result;
30029   return jresult;
30030 }
30031
30032
30033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30034   void * jresult ;
30035   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30036   std::size_t arg2 ;
30037   Dali::Vector2 *result = 0 ;
30038
30039   arg1 = (Dali::TouchData *)jarg1;
30040   arg2 = (std::size_t)jarg2;
30041   {
30042     try {
30043       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30044     } catch (std::out_of_range& e) {
30045       {
30046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30047       };
30048     } catch (std::exception& e) {
30049       {
30050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30051       };
30052     } catch (Dali::DaliException e) {
30053       {
30054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30055       };
30056     } catch (...) {
30057       {
30058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30059       };
30060     }
30061   }
30062
30063   jresult = (void *)result;
30064   return jresult;
30065 }
30066
30067
30068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30069   float jresult ;
30070   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30071   std::size_t arg2 ;
30072   float result;
30073
30074   arg1 = (Dali::TouchData *)jarg1;
30075   arg2 = (std::size_t)jarg2;
30076   {
30077     try {
30078       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30079     } catch (std::out_of_range& e) {
30080       {
30081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30082       };
30083     } catch (std::exception& e) {
30084       {
30085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30086       };
30087     } catch (Dali::DaliException e) {
30088       {
30089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30090       };
30091     } catch (...) {
30092       {
30093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30094       };
30095     }
30096   }
30097
30098   jresult = result;
30099   return jresult;
30100 }
30101
30102
30103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30104   void * jresult ;
30105   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30106   std::size_t arg2 ;
30107   Dali::Vector2 *result = 0 ;
30108
30109   arg1 = (Dali::TouchData *)jarg1;
30110   arg2 = (std::size_t)jarg2;
30111   {
30112     try {
30113       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30114     } catch (std::out_of_range& e) {
30115       {
30116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30117       };
30118     } catch (std::exception& e) {
30119       {
30120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30121       };
30122     } catch (Dali::DaliException e) {
30123       {
30124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30125       };
30126     } catch (...) {
30127       {
30128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30129       };
30130     }
30131   }
30132
30133   jresult = (void *)result;
30134   return jresult;
30135 }
30136
30137
30138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30139   float jresult ;
30140   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30141   std::size_t arg2 ;
30142   float result;
30143
30144   arg1 = (Dali::TouchData *)jarg1;
30145   arg2 = (std::size_t)jarg2;
30146   {
30147     try {
30148       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30149     } catch (std::out_of_range& e) {
30150       {
30151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30152       };
30153     } catch (std::exception& e) {
30154       {
30155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30156       };
30157     } catch (Dali::DaliException e) {
30158       {
30159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30160       };
30161     } catch (...) {
30162       {
30163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30164       };
30165     }
30166   }
30167
30168   jresult = result;
30169   return jresult;
30170 }
30171
30172
30173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30174   void * jresult ;
30175   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30176   std::size_t arg2 ;
30177   Dali::Degree result;
30178
30179   arg1 = (Dali::TouchData *)jarg1;
30180   arg2 = (std::size_t)jarg2;
30181   {
30182     try {
30183       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30184     } catch (std::out_of_range& e) {
30185       {
30186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30187       };
30188     } catch (std::exception& e) {
30189       {
30190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30191       };
30192     } catch (Dali::DaliException e) {
30193       {
30194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30195       };
30196     } catch (...) {
30197       {
30198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30199       };
30200     }
30201   }
30202
30203   jresult = new Dali::Degree((const Dali::Degree &)result);
30204   return jresult;
30205 }
30206
30207
30208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30209   int jresult ;
30210   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30211   std::size_t arg2 ;
30212   Dali::MouseButton::Type result;
30213
30214   arg1 = (Dali::TouchData *)jarg1;
30215   arg2 = (std::size_t)jarg2;
30216   {
30217     try {
30218       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30219     } catch (std::out_of_range& e) {
30220       {
30221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30222       };
30223     } catch (std::exception& e) {
30224       {
30225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30226       };
30227     } catch (Dali::DaliException e) {
30228       {
30229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30230       };
30231     } catch (...) {
30232       {
30233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30234       };
30235     }
30236   }
30237
30238   jresult = static_cast< int >(result);
30239   return jresult;
30240 }
30241
30242
30243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30244   void * jresult ;
30245   Dali::GestureDetector *result = 0 ;
30246
30247   {
30248     try {
30249       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30250     } catch (std::out_of_range& e) {
30251       {
30252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30253       };
30254     } catch (std::exception& e) {
30255       {
30256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30257       };
30258     } catch (Dali::DaliException e) {
30259       {
30260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30261       };
30262     } catch (...) {
30263       {
30264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30265       };
30266     }
30267   }
30268
30269   jresult = (void *)result;
30270   return jresult;
30271 }
30272
30273
30274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30275   void * jresult ;
30276   Dali::BaseHandle arg1 ;
30277   Dali::BaseHandle *argp1 ;
30278   Dali::GestureDetector result;
30279
30280   argp1 = (Dali::BaseHandle *)jarg1;
30281   if (!argp1) {
30282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30283     return 0;
30284   }
30285   arg1 = *argp1;
30286   {
30287     try {
30288       result = Dali::GestureDetector::DownCast(arg1);
30289     } catch (std::out_of_range& e) {
30290       {
30291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30292       };
30293     } catch (std::exception& e) {
30294       {
30295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30296       };
30297     } catch (Dali::DaliException e) {
30298       {
30299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30300       };
30301     } catch (...) {
30302       {
30303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30304       };
30305     }
30306   }
30307
30308   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30309   return jresult;
30310 }
30311
30312
30313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30314   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30315
30316   arg1 = (Dali::GestureDetector *)jarg1;
30317   {
30318     try {
30319       delete arg1;
30320     } catch (std::out_of_range& e) {
30321       {
30322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30323       };
30324     } catch (std::exception& e) {
30325       {
30326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30327       };
30328     } catch (Dali::DaliException e) {
30329       {
30330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30331       };
30332     } catch (...) {
30333       {
30334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30335       };
30336     }
30337   }
30338
30339 }
30340
30341
30342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30343   void * jresult ;
30344   Dali::GestureDetector *arg1 = 0 ;
30345   Dali::GestureDetector *result = 0 ;
30346
30347   arg1 = (Dali::GestureDetector *)jarg1;
30348   if (!arg1) {
30349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30350     return 0;
30351   }
30352   {
30353     try {
30354       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30355     } catch (std::out_of_range& e) {
30356       {
30357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30358       };
30359     } catch (std::exception& e) {
30360       {
30361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30362       };
30363     } catch (Dali::DaliException e) {
30364       {
30365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30366       };
30367     } catch (...) {
30368       {
30369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30370       };
30371     }
30372   }
30373
30374   jresult = (void *)result;
30375   return jresult;
30376 }
30377
30378
30379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30380   void * jresult ;
30381   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30382   Dali::GestureDetector *arg2 = 0 ;
30383   Dali::GestureDetector *result = 0 ;
30384
30385   arg1 = (Dali::GestureDetector *)jarg1;
30386   arg2 = (Dali::GestureDetector *)jarg2;
30387   if (!arg2) {
30388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30389     return 0;
30390   }
30391   {
30392     try {
30393       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30394     } catch (std::out_of_range& e) {
30395       {
30396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30397       };
30398     } catch (std::exception& e) {
30399       {
30400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30401       };
30402     } catch (Dali::DaliException e) {
30403       {
30404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30405       };
30406     } catch (...) {
30407       {
30408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30409       };
30410     }
30411   }
30412
30413   jresult = (void *)result;
30414   return jresult;
30415 }
30416
30417
30418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30419   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30420   Dali::Actor arg2 ;
30421   Dali::Actor *argp2 ;
30422
30423   arg1 = (Dali::GestureDetector *)jarg1;
30424   argp2 = (Dali::Actor *)jarg2;
30425   if (!argp2) {
30426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30427     return ;
30428   }
30429   arg2 = *argp2;
30430   {
30431     try {
30432       (arg1)->Attach(arg2);
30433     } catch (std::out_of_range& e) {
30434       {
30435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30436       };
30437     } catch (std::exception& e) {
30438       {
30439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30440       };
30441     } catch (Dali::DaliException e) {
30442       {
30443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30444       };
30445     } catch (...) {
30446       {
30447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30448       };
30449     }
30450   }
30451
30452 }
30453
30454
30455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30456   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30457   Dali::Actor arg2 ;
30458   Dali::Actor *argp2 ;
30459
30460   arg1 = (Dali::GestureDetector *)jarg1;
30461   argp2 = (Dali::Actor *)jarg2;
30462   if (!argp2) {
30463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30464     return ;
30465   }
30466   arg2 = *argp2;
30467   {
30468     try {
30469       (arg1)->Detach(arg2);
30470     } catch (std::out_of_range& e) {
30471       {
30472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30473       };
30474     } catch (std::exception& e) {
30475       {
30476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30477       };
30478     } catch (Dali::DaliException e) {
30479       {
30480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30481       };
30482     } catch (...) {
30483       {
30484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30485       };
30486     }
30487   }
30488
30489 }
30490
30491
30492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30493   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30494
30495   arg1 = (Dali::GestureDetector *)jarg1;
30496   {
30497     try {
30498       (arg1)->DetachAll();
30499     } catch (std::out_of_range& e) {
30500       {
30501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30502       };
30503     } catch (std::exception& e) {
30504       {
30505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30506       };
30507     } catch (Dali::DaliException e) {
30508       {
30509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30510       };
30511     } catch (...) {
30512       {
30513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30514       };
30515     }
30516   }
30517
30518 }
30519
30520
30521 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30522   unsigned long jresult ;
30523   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30524   size_t result;
30525
30526   arg1 = (Dali::GestureDetector *)jarg1;
30527   {
30528     try {
30529       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30530     } catch (std::out_of_range& e) {
30531       {
30532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30533       };
30534     } catch (std::exception& e) {
30535       {
30536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30537       };
30538     } catch (Dali::DaliException e) {
30539       {
30540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30541       };
30542     } catch (...) {
30543       {
30544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30545       };
30546     }
30547   }
30548
30549   jresult = (unsigned long)result;
30550   return jresult;
30551 }
30552
30553
30554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30555   void * jresult ;
30556   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30557   size_t arg2 ;
30558   Dali::Actor result;
30559
30560   arg1 = (Dali::GestureDetector *)jarg1;
30561   arg2 = (size_t)jarg2;
30562   {
30563     try {
30564       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30565     } catch (std::out_of_range& e) {
30566       {
30567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30568       };
30569     } catch (std::exception& e) {
30570       {
30571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30572       };
30573     } catch (Dali::DaliException e) {
30574       {
30575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30576       };
30577     } catch (...) {
30578       {
30579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30580       };
30581     }
30582   }
30583
30584   jresult = new Dali::Actor((const Dali::Actor &)result);
30585   return jresult;
30586 }
30587
30588
30589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30590   void * jresult ;
30591   Dali::Gesture *arg1 = 0 ;
30592   Dali::Gesture *result = 0 ;
30593
30594   arg1 = (Dali::Gesture *)jarg1;
30595   if (!arg1) {
30596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30597     return 0;
30598   }
30599   {
30600     try {
30601       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30602     } catch (std::out_of_range& e) {
30603       {
30604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30605       };
30606     } catch (std::exception& e) {
30607       {
30608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30609       };
30610     } catch (Dali::DaliException e) {
30611       {
30612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30613       };
30614     } catch (...) {
30615       {
30616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30617       };
30618     }
30619   }
30620
30621   jresult = (void *)result;
30622   return jresult;
30623 }
30624
30625
30626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30627   void * jresult ;
30628   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30629   Dali::Gesture *arg2 = 0 ;
30630   Dali::Gesture *result = 0 ;
30631
30632   arg1 = (Dali::Gesture *)jarg1;
30633   arg2 = (Dali::Gesture *)jarg2;
30634   if (!arg2) {
30635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30636     return 0;
30637   }
30638   {
30639     try {
30640       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30641     } catch (std::out_of_range& e) {
30642       {
30643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30644       };
30645     } catch (std::exception& e) {
30646       {
30647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30648       };
30649     } catch (Dali::DaliException e) {
30650       {
30651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30652       };
30653     } catch (...) {
30654       {
30655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30656       };
30657     }
30658   }
30659
30660   jresult = (void *)result;
30661   return jresult;
30662 }
30663
30664
30665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30666   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30667
30668   arg1 = (Dali::Gesture *)jarg1;
30669   {
30670     try {
30671       delete arg1;
30672     } catch (std::out_of_range& e) {
30673       {
30674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30675       };
30676     } catch (std::exception& e) {
30677       {
30678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30679       };
30680     } catch (Dali::DaliException e) {
30681       {
30682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30683       };
30684     } catch (...) {
30685       {
30686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30687       };
30688     }
30689   }
30690
30691 }
30692
30693
30694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30695   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30696   Dali::Gesture::Type arg2 ;
30697
30698   arg1 = (Dali::Gesture *)jarg1;
30699   arg2 = (Dali::Gesture::Type)jarg2;
30700   if (arg1) (arg1)->type = arg2;
30701 }
30702
30703
30704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30705   int jresult ;
30706   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30707   Dali::Gesture::Type result;
30708
30709   arg1 = (Dali::Gesture *)jarg1;
30710   result = (Dali::Gesture::Type) ((arg1)->type);
30711   jresult = (int)result;
30712   return jresult;
30713 }
30714
30715
30716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30717   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30718   Dali::Gesture::State arg2 ;
30719
30720   arg1 = (Dali::Gesture *)jarg1;
30721   arg2 = (Dali::Gesture::State)jarg2;
30722   if (arg1) (arg1)->state = arg2;
30723 }
30724
30725
30726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30727   int jresult ;
30728   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30729   Dali::Gesture::State result;
30730
30731   arg1 = (Dali::Gesture *)jarg1;
30732   result = (Dali::Gesture::State) ((arg1)->state);
30733   jresult = (int)result;
30734   return jresult;
30735 }
30736
30737
30738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30739   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30740   unsigned int arg2 ;
30741
30742   arg1 = (Dali::Gesture *)jarg1;
30743   arg2 = (unsigned int)jarg2;
30744   if (arg1) (arg1)->time = arg2;
30745 }
30746
30747
30748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30749   unsigned int jresult ;
30750   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30751   unsigned int result;
30752
30753   arg1 = (Dali::Gesture *)jarg1;
30754   result = (unsigned int) ((arg1)->time);
30755   jresult = result;
30756   return jresult;
30757 }
30758
30759
30760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30761   void * jresult ;
30762   Dali::HoverEvent *result = 0 ;
30763
30764   {
30765     try {
30766       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30767     } catch (std::out_of_range& e) {
30768       {
30769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30770       };
30771     } catch (std::exception& e) {
30772       {
30773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30774       };
30775     } catch (Dali::DaliException e) {
30776       {
30777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30778       };
30779     } catch (...) {
30780       {
30781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30782       };
30783     }
30784   }
30785
30786   jresult = (void *)result;
30787   return jresult;
30788 }
30789
30790
30791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30792   void * jresult ;
30793   unsigned long arg1 ;
30794   Dali::HoverEvent *result = 0 ;
30795
30796   arg1 = (unsigned long)jarg1;
30797   {
30798     try {
30799       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30800     } catch (std::out_of_range& e) {
30801       {
30802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30803       };
30804     } catch (std::exception& e) {
30805       {
30806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30807       };
30808     } catch (Dali::DaliException e) {
30809       {
30810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30811       };
30812     } catch (...) {
30813       {
30814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30815       };
30816     }
30817   }
30818
30819   jresult = (void *)result;
30820   return jresult;
30821 }
30822
30823
30824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30825   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30826
30827   arg1 = (Dali::HoverEvent *)jarg1;
30828   {
30829     try {
30830       delete arg1;
30831     } catch (std::out_of_range& e) {
30832       {
30833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30834       };
30835     } catch (std::exception& e) {
30836       {
30837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30838       };
30839     } catch (Dali::DaliException e) {
30840       {
30841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30842       };
30843     } catch (...) {
30844       {
30845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30846       };
30847     }
30848   }
30849
30850 }
30851
30852
30853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30854   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30855   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30856
30857   arg1 = (Dali::HoverEvent *)jarg1;
30858   arg2 = (Dali::TouchPointContainer *)jarg2;
30859   if (arg1) (arg1)->points = *arg2;
30860 }
30861
30862
30863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30864   void * jresult ;
30865   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30866   Dali::TouchPointContainer *result = 0 ;
30867
30868   arg1 = (Dali::HoverEvent *)jarg1;
30869   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30870   jresult = (void *)result;
30871   return jresult;
30872 }
30873
30874
30875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30876   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30877   unsigned long arg2 ;
30878
30879   arg1 = (Dali::HoverEvent *)jarg1;
30880   arg2 = (unsigned long)jarg2;
30881   if (arg1) (arg1)->time = arg2;
30882 }
30883
30884
30885 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30886   unsigned long jresult ;
30887   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30888   unsigned long result;
30889
30890   arg1 = (Dali::HoverEvent *)jarg1;
30891   result = (unsigned long) ((arg1)->time);
30892   jresult = (unsigned long)result;
30893   return jresult;
30894 }
30895
30896
30897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30898   unsigned int jresult ;
30899   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30900   unsigned int result;
30901
30902   arg1 = (Dali::HoverEvent *)jarg1;
30903   {
30904     try {
30905       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30906     } catch (std::out_of_range& e) {
30907       {
30908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30909       };
30910     } catch (std::exception& e) {
30911       {
30912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30913       };
30914     } catch (Dali::DaliException e) {
30915       {
30916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30917       };
30918     } catch (...) {
30919       {
30920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30921       };
30922     }
30923   }
30924
30925   jresult = result;
30926   return jresult;
30927 }
30928
30929
30930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30931   void * jresult ;
30932   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30933   unsigned int arg2 ;
30934   Dali::TouchPoint *result = 0 ;
30935
30936   arg1 = (Dali::HoverEvent *)jarg1;
30937   arg2 = (unsigned int)jarg2;
30938   {
30939     try {
30940       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30941     } catch (std::out_of_range& e) {
30942       {
30943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30944       };
30945     } catch (std::exception& e) {
30946       {
30947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30948       };
30949     } catch (Dali::DaliException e) {
30950       {
30951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30952       };
30953     } catch (...) {
30954       {
30955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30956       };
30957     }
30958   }
30959
30960   jresult = (void *)result;
30961   return jresult;
30962 }
30963
30964
30965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30966   void * jresult ;
30967   Dali::KeyEvent *result = 0 ;
30968
30969   {
30970     try {
30971       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30972     } catch (std::out_of_range& e) {
30973       {
30974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30975       };
30976     } catch (std::exception& e) {
30977       {
30978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30979       };
30980     } catch (Dali::DaliException e) {
30981       {
30982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30983       };
30984     } catch (...) {
30985       {
30986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30987       };
30988     }
30989   }
30990
30991   jresult = (void *)result;
30992   return jresult;
30993 }
30994
30995
30996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30997   void * jresult ;
30998   std::string *arg1 = 0 ;
30999   std::string *arg2 = 0 ;
31000   int arg3 ;
31001   int arg4 ;
31002   unsigned long arg5 ;
31003   Dali::KeyEvent::State *arg6 = 0 ;
31004   Dali::KeyEvent::State temp6 ;
31005   Dali::KeyEvent *result = 0 ;
31006
31007   if (!jarg1) {
31008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31009     return 0;
31010   }
31011   std::string arg1_str(jarg1);
31012   arg1 = &arg1_str;
31013   if (!jarg2) {
31014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31015     return 0;
31016   }
31017   std::string arg2_str(jarg2);
31018   arg2 = &arg2_str;
31019   arg3 = (int)jarg3;
31020   arg4 = (int)jarg4;
31021   arg5 = (unsigned long)jarg5;
31022   temp6 = (Dali::KeyEvent::State)jarg6;
31023   arg6 = &temp6;
31024   {
31025     try {
31026       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31027     } catch (std::out_of_range& e) {
31028       {
31029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31030       };
31031     } catch (std::exception& e) {
31032       {
31033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31034       };
31035     } catch (Dali::DaliException e) {
31036       {
31037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31038       };
31039     } catch (...) {
31040       {
31041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31042       };
31043     }
31044   }
31045
31046   jresult = (void *)result;
31047
31048   //argout typemap for const std::string&
31049
31050
31051   //argout typemap for const std::string&
31052
31053   return jresult;
31054 }
31055
31056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31057   void * jresult ;
31058   Dali::KeyEvent *arg1 = 0 ;
31059   Dali::KeyEvent *result = 0 ;
31060
31061   arg1 = (Dali::KeyEvent *)jarg1;
31062   if (!arg1) {
31063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31064     return 0;
31065   }
31066   {
31067     try {
31068       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31069     } catch (std::out_of_range& e) {
31070       {
31071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31072       };
31073     } catch (std::exception& e) {
31074       {
31075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31076       };
31077     } catch (Dali::DaliException e) {
31078       {
31079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31080       };
31081     } catch (...) {
31082       {
31083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31084       };
31085     }
31086   }
31087
31088   jresult = (void *)result;
31089   return jresult;
31090 }
31091
31092
31093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31094   void * jresult ;
31095   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31096   Dali::KeyEvent *arg2 = 0 ;
31097   Dali::KeyEvent *result = 0 ;
31098
31099   arg1 = (Dali::KeyEvent *)jarg1;
31100   arg2 = (Dali::KeyEvent *)jarg2;
31101   if (!arg2) {
31102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31103     return 0;
31104   }
31105   {
31106     try {
31107       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31108     } catch (std::out_of_range& e) {
31109       {
31110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31111       };
31112     } catch (std::exception& e) {
31113       {
31114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31115       };
31116     } catch (Dali::DaliException e) {
31117       {
31118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31119       };
31120     } catch (...) {
31121       {
31122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31123       };
31124     }
31125   }
31126
31127   jresult = (void *)result;
31128   return jresult;
31129 }
31130
31131
31132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31133   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31134
31135   arg1 = (Dali::KeyEvent *)jarg1;
31136   {
31137     try {
31138       delete arg1;
31139     } catch (std::out_of_range& e) {
31140       {
31141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31142       };
31143     } catch (std::exception& e) {
31144       {
31145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31146       };
31147     } catch (Dali::DaliException e) {
31148       {
31149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31150       };
31151     } catch (...) {
31152       {
31153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31154       };
31155     }
31156   }
31157
31158 }
31159
31160
31161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31162   unsigned int jresult ;
31163   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31164   bool result;
31165
31166   arg1 = (Dali::KeyEvent *)jarg1;
31167   {
31168     try {
31169       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31170     } catch (std::out_of_range& e) {
31171       {
31172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31173       };
31174     } catch (std::exception& e) {
31175       {
31176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31177       };
31178     } catch (Dali::DaliException e) {
31179       {
31180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31181       };
31182     } catch (...) {
31183       {
31184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31185       };
31186     }
31187   }
31188
31189   jresult = result;
31190   return jresult;
31191 }
31192
31193
31194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31195   unsigned int jresult ;
31196   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31197   bool result;
31198
31199   arg1 = (Dali::KeyEvent *)jarg1;
31200   {
31201     try {
31202       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31203     } catch (std::out_of_range& e) {
31204       {
31205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31206       };
31207     } catch (std::exception& e) {
31208       {
31209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31210       };
31211     } catch (Dali::DaliException e) {
31212       {
31213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31214       };
31215     } catch (...) {
31216       {
31217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31218       };
31219     }
31220   }
31221
31222   jresult = result;
31223   return jresult;
31224 }
31225
31226
31227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31228   unsigned int jresult ;
31229   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31230   bool result;
31231
31232   arg1 = (Dali::KeyEvent *)jarg1;
31233   {
31234     try {
31235       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31236     } catch (std::out_of_range& e) {
31237       {
31238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31239       };
31240     } catch (std::exception& e) {
31241       {
31242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31243       };
31244     } catch (Dali::DaliException e) {
31245       {
31246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31247       };
31248     } catch (...) {
31249       {
31250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31251       };
31252     }
31253   }
31254
31255   jresult = result;
31256   return jresult;
31257 }
31258
31259
31260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31261   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31262   std::string *arg2 = 0 ;
31263
31264   arg1 = (Dali::KeyEvent *)jarg1;
31265   if (!jarg2) {
31266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31267     return ;
31268   }
31269   std::string arg2_str(jarg2);
31270   arg2 = &arg2_str;
31271   if (arg1) (arg1)->keyPressedName = *arg2;
31272
31273   //argout typemap for const std::string&
31274
31275 }
31276
31277
31278 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31279   char * jresult ;
31280
31281   if( jarg1 == NULL )
31282   {
31283     jresult = SWIG_csharp_string_callback( "" );
31284   }
31285   else
31286   {
31287     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31288     std::string *result = 0;
31289
31290     arg1 = ( Dali::KeyEvent * )jarg1;
31291     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31292     jresult = SWIG_csharp_string_callback( result->c_str() );
31293   }
31294
31295   return jresult;
31296 }
31297
31298
31299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31300   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31301   std::string *arg2 = 0 ;
31302
31303   arg1 = (Dali::KeyEvent *)jarg1;
31304   if (!jarg2) {
31305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31306     return ;
31307   }
31308   std::string arg2_str(jarg2);
31309   arg2 = &arg2_str;
31310   if (arg1) (arg1)->keyPressed = *arg2;
31311
31312   //argout typemap for const std::string&
31313
31314 }
31315
31316
31317 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31318   char * jresult ;
31319   if( NULL == jarg1 )
31320   {
31321     jresult = SWIG_csharp_string_callback( "" );
31322   }
31323   else
31324   {
31325     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31326     std::string *result = 0;
31327
31328     arg1 = ( Dali::KeyEvent * )jarg1;
31329     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31330     jresult = SWIG_csharp_string_callback( result->c_str() );
31331   }
31332   return jresult;
31333 }
31334
31335
31336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31337   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31338   int arg2 ;
31339
31340   arg1 = (Dali::KeyEvent *)jarg1;
31341   arg2 = (int)jarg2;
31342   if (arg1) (arg1)->keyCode = arg2;
31343 }
31344
31345
31346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31347   int jresult ;
31348   if( NULL == jarg1 )
31349   {
31350     jresult = -1;
31351   }
31352   else
31353   {
31354     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31355     int result;
31356
31357     arg1 = ( Dali::KeyEvent * )jarg1;
31358     result = (int)( ( arg1 )->keyCode );
31359     jresult = result;
31360   }
31361   return jresult;
31362 }
31363
31364
31365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31366   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31367   int arg2 ;
31368
31369   arg1 = (Dali::KeyEvent *)jarg1;
31370   arg2 = (int)jarg2;
31371   if (arg1) (arg1)->keyModifier = arg2;
31372 }
31373
31374
31375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31376   int jresult ;
31377   if( jarg1 == NULL )
31378   {
31379     jresult = -1;
31380   }
31381   else
31382   {
31383     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31384     int result;
31385
31386     arg1 = ( Dali::KeyEvent * )jarg1;
31387     result = (int)( ( arg1 )->keyModifier );
31388     jresult = result;
31389   }
31390   return jresult;
31391 }
31392
31393
31394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31395   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31396   unsigned long arg2 ;
31397
31398   arg1 = (Dali::KeyEvent *)jarg1;
31399   arg2 = (unsigned long)jarg2;
31400   if (arg1) (arg1)->time = arg2;
31401 }
31402
31403
31404 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31405   unsigned long jresult ;
31406   if( jarg1 == NULL )
31407   {
31408     jresult = 0;
31409   }
31410   else
31411   {
31412     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31413     unsigned long result;
31414
31415     arg1 = ( Dali::KeyEvent * )jarg1;
31416     result = (unsigned long)( ( arg1 )->time );
31417     jresult = (unsigned long)result;
31418   }
31419   return jresult;
31420 }
31421
31422
31423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31424   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31425   Dali::KeyEvent::State arg2 ;
31426
31427   arg1 = (Dali::KeyEvent *)jarg1;
31428   arg2 = (Dali::KeyEvent::State)jarg2;
31429   if (arg1) (arg1)->state = arg2;
31430 }
31431
31432
31433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31434   int jresult ;
31435   if( jarg1 == NULL )
31436   {
31437     jresult = -1;
31438   }
31439   else
31440   {
31441     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31442     Dali::KeyEvent::State result;
31443
31444     arg1 = ( Dali::KeyEvent * )jarg1;
31445     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31446     jresult = (int)result;
31447   }
31448   return jresult;
31449 }
31450
31451
31452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31453   void * jresult ;
31454   Dali::LongPressGestureDetector *result = 0 ;
31455
31456   {
31457     try {
31458       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31459     } catch (std::out_of_range& e) {
31460       {
31461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31462       };
31463     } catch (std::exception& e) {
31464       {
31465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31466       };
31467     } catch (Dali::DaliException e) {
31468       {
31469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31470       };
31471     } catch (...) {
31472       {
31473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31474       };
31475     }
31476   }
31477
31478   jresult = (void *)result;
31479   return jresult;
31480 }
31481
31482
31483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31484   void * jresult ;
31485   Dali::LongPressGestureDetector result;
31486
31487   {
31488     try {
31489       result = Dali::LongPressGestureDetector::New();
31490     } catch (std::out_of_range& e) {
31491       {
31492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31493       };
31494     } catch (std::exception& e) {
31495       {
31496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31497       };
31498     } catch (Dali::DaliException e) {
31499       {
31500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31501       };
31502     } catch (...) {
31503       {
31504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31505       };
31506     }
31507   }
31508
31509   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31510   return jresult;
31511 }
31512
31513
31514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31515   void * jresult ;
31516   unsigned int arg1 ;
31517   Dali::LongPressGestureDetector result;
31518
31519   arg1 = (unsigned int)jarg1;
31520   {
31521     try {
31522       result = Dali::LongPressGestureDetector::New(arg1);
31523     } catch (std::out_of_range& e) {
31524       {
31525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31526       };
31527     } catch (std::exception& e) {
31528       {
31529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31530       };
31531     } catch (Dali::DaliException e) {
31532       {
31533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31534       };
31535     } catch (...) {
31536       {
31537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31538       };
31539     }
31540   }
31541
31542   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31543   return jresult;
31544 }
31545
31546
31547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31548   void * jresult ;
31549   unsigned int arg1 ;
31550   unsigned int arg2 ;
31551   Dali::LongPressGestureDetector result;
31552
31553   arg1 = (unsigned int)jarg1;
31554   arg2 = (unsigned int)jarg2;
31555   {
31556     try {
31557       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31558     } catch (std::out_of_range& e) {
31559       {
31560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31561       };
31562     } catch (std::exception& e) {
31563       {
31564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31565       };
31566     } catch (Dali::DaliException e) {
31567       {
31568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31569       };
31570     } catch (...) {
31571       {
31572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31573       };
31574     }
31575   }
31576
31577   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31578   return jresult;
31579 }
31580
31581
31582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31583   void * jresult ;
31584   Dali::BaseHandle arg1 ;
31585   Dali::BaseHandle *argp1 ;
31586   Dali::LongPressGestureDetector result;
31587
31588   argp1 = (Dali::BaseHandle *)jarg1;
31589   if (!argp1) {
31590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31591     return 0;
31592   }
31593   arg1 = *argp1;
31594   {
31595     try {
31596       result = Dali::LongPressGestureDetector::DownCast(arg1);
31597     } catch (std::out_of_range& e) {
31598       {
31599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31600       };
31601     } catch (std::exception& e) {
31602       {
31603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31604       };
31605     } catch (Dali::DaliException e) {
31606       {
31607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31608       };
31609     } catch (...) {
31610       {
31611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31612       };
31613     }
31614   }
31615
31616   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31617   return jresult;
31618 }
31619
31620
31621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31622   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31623
31624   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31625   {
31626     try {
31627       delete arg1;
31628     } catch (std::out_of_range& e) {
31629       {
31630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31631       };
31632     } catch (std::exception& e) {
31633       {
31634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31635       };
31636     } catch (Dali::DaliException e) {
31637       {
31638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31639       };
31640     } catch (...) {
31641       {
31642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31643       };
31644     }
31645   }
31646
31647 }
31648
31649
31650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31651   void * jresult ;
31652   Dali::LongPressGestureDetector *arg1 = 0 ;
31653   Dali::LongPressGestureDetector *result = 0 ;
31654
31655   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31656   if (!arg1) {
31657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31658     return 0;
31659   }
31660   {
31661     try {
31662       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31663     } catch (std::out_of_range& e) {
31664       {
31665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31666       };
31667     } catch (std::exception& e) {
31668       {
31669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31670       };
31671     } catch (Dali::DaliException e) {
31672       {
31673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31674       };
31675     } catch (...) {
31676       {
31677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31678       };
31679     }
31680   }
31681
31682   jresult = (void *)result;
31683   return jresult;
31684 }
31685
31686
31687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31688   void * jresult ;
31689   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31690   Dali::LongPressGestureDetector *arg2 = 0 ;
31691   Dali::LongPressGestureDetector *result = 0 ;
31692
31693   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31694   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31695   if (!arg2) {
31696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31697     return 0;
31698   }
31699   {
31700     try {
31701       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31702     } catch (std::out_of_range& e) {
31703       {
31704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31705       };
31706     } catch (std::exception& e) {
31707       {
31708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31709       };
31710     } catch (Dali::DaliException e) {
31711       {
31712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31713       };
31714     } catch (...) {
31715       {
31716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31717       };
31718     }
31719   }
31720
31721   jresult = (void *)result;
31722   return jresult;
31723 }
31724
31725
31726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31727   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31728   unsigned int arg2 ;
31729
31730   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31731   arg2 = (unsigned int)jarg2;
31732   {
31733     try {
31734       (arg1)->SetTouchesRequired(arg2);
31735     } catch (std::out_of_range& e) {
31736       {
31737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31738       };
31739     } catch (std::exception& e) {
31740       {
31741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31742       };
31743     } catch (Dali::DaliException e) {
31744       {
31745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31746       };
31747     } catch (...) {
31748       {
31749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31750       };
31751     }
31752   }
31753
31754 }
31755
31756
31757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31758   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31759   unsigned int arg2 ;
31760   unsigned int arg3 ;
31761
31762   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31763   arg2 = (unsigned int)jarg2;
31764   arg3 = (unsigned int)jarg3;
31765   {
31766     try {
31767       (arg1)->SetTouchesRequired(arg2,arg3);
31768     } catch (std::out_of_range& e) {
31769       {
31770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31771       };
31772     } catch (std::exception& e) {
31773       {
31774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31775       };
31776     } catch (Dali::DaliException e) {
31777       {
31778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31779       };
31780     } catch (...) {
31781       {
31782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31783       };
31784     }
31785   }
31786
31787 }
31788
31789
31790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31791   unsigned int jresult ;
31792   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31793   unsigned int result;
31794
31795   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31796   {
31797     try {
31798       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31799     } catch (std::out_of_range& e) {
31800       {
31801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31802       };
31803     } catch (std::exception& e) {
31804       {
31805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31806       };
31807     } catch (Dali::DaliException e) {
31808       {
31809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31810       };
31811     } catch (...) {
31812       {
31813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31814       };
31815     }
31816   }
31817
31818   jresult = result;
31819   return jresult;
31820 }
31821
31822
31823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31824   unsigned int jresult ;
31825   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31826   unsigned int result;
31827
31828   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31829   {
31830     try {
31831       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31832     } catch (std::out_of_range& e) {
31833       {
31834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31835       };
31836     } catch (std::exception& e) {
31837       {
31838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31839       };
31840     } catch (Dali::DaliException e) {
31841       {
31842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31843       };
31844     } catch (...) {
31845       {
31846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31847       };
31848     }
31849   }
31850
31851   jresult = result;
31852   return jresult;
31853 }
31854
31855
31856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31857   void * jresult ;
31858   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31859   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31860
31861   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31862   {
31863     try {
31864       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31865     } catch (std::out_of_range& e) {
31866       {
31867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31868       };
31869     } catch (std::exception& e) {
31870       {
31871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31872       };
31873     } catch (Dali::DaliException e) {
31874       {
31875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31876       };
31877     } catch (...) {
31878       {
31879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31880       };
31881     }
31882   }
31883
31884   jresult = (void *)result;
31885   return jresult;
31886 }
31887
31888
31889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31890   void * jresult ;
31891   Dali::Gesture::State arg1 ;
31892   Dali::LongPressGesture *result = 0 ;
31893
31894   arg1 = (Dali::Gesture::State)jarg1;
31895   {
31896     try {
31897       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31898     } catch (std::out_of_range& e) {
31899       {
31900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31901       };
31902     } catch (std::exception& e) {
31903       {
31904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31905       };
31906     } catch (Dali::DaliException e) {
31907       {
31908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31909       };
31910     } catch (...) {
31911       {
31912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31913       };
31914     }
31915   }
31916
31917   jresult = (void *)result;
31918   return jresult;
31919 }
31920
31921
31922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31923   void * jresult ;
31924   Dali::LongPressGesture *arg1 = 0 ;
31925   Dali::LongPressGesture *result = 0 ;
31926
31927   arg1 = (Dali::LongPressGesture *)jarg1;
31928   if (!arg1) {
31929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31930     return 0;
31931   }
31932   {
31933     try {
31934       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31935     } catch (std::out_of_range& e) {
31936       {
31937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31938       };
31939     } catch (std::exception& e) {
31940       {
31941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31942       };
31943     } catch (Dali::DaliException e) {
31944       {
31945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31946       };
31947     } catch (...) {
31948       {
31949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31950       };
31951     }
31952   }
31953
31954   jresult = (void *)result;
31955   return jresult;
31956 }
31957
31958
31959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31960   void * jresult ;
31961   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31962   Dali::LongPressGesture *arg2 = 0 ;
31963   Dali::LongPressGesture *result = 0 ;
31964
31965   arg1 = (Dali::LongPressGesture *)jarg1;
31966   arg2 = (Dali::LongPressGesture *)jarg2;
31967   if (!arg2) {
31968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31969     return 0;
31970   }
31971   {
31972     try {
31973       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31974     } catch (std::out_of_range& e) {
31975       {
31976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31977       };
31978     } catch (std::exception& e) {
31979       {
31980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31981       };
31982     } catch (Dali::DaliException e) {
31983       {
31984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31985       };
31986     } catch (...) {
31987       {
31988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31989       };
31990     }
31991   }
31992
31993   jresult = (void *)result;
31994   return jresult;
31995 }
31996
31997
31998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31999   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32000
32001   arg1 = (Dali::LongPressGesture *)jarg1;
32002   {
32003     try {
32004       delete arg1;
32005     } catch (std::out_of_range& e) {
32006       {
32007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32008       };
32009     } catch (std::exception& e) {
32010       {
32011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32012       };
32013     } catch (Dali::DaliException e) {
32014       {
32015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32016       };
32017     } catch (...) {
32018       {
32019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32020       };
32021     }
32022   }
32023
32024 }
32025
32026
32027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32028   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32029   unsigned int arg2 ;
32030
32031   arg1 = (Dali::LongPressGesture *)jarg1;
32032   arg2 = (unsigned int)jarg2;
32033   if (arg1) (arg1)->numberOfTouches = arg2;
32034 }
32035
32036
32037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32038   unsigned int jresult ;
32039   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32040   unsigned int result;
32041
32042   arg1 = (Dali::LongPressGesture *)jarg1;
32043   result = (unsigned int) ((arg1)->numberOfTouches);
32044   jresult = result;
32045   return jresult;
32046 }
32047
32048
32049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32050   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32051   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32052
32053   arg1 = (Dali::LongPressGesture *)jarg1;
32054   arg2 = (Dali::Vector2 *)jarg2;
32055   if (arg1) (arg1)->screenPoint = *arg2;
32056 }
32057
32058
32059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32060   void * jresult ;
32061   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32062   Dali::Vector2 *result = 0 ;
32063
32064   arg1 = (Dali::LongPressGesture *)jarg1;
32065   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32066   jresult = (void *)result;
32067   return jresult;
32068 }
32069
32070
32071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32072   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32073   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32074
32075   arg1 = (Dali::LongPressGesture *)jarg1;
32076   arg2 = (Dali::Vector2 *)jarg2;
32077   if (arg1) (arg1)->localPoint = *arg2;
32078 }
32079
32080
32081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32082   void * jresult ;
32083   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32084   Dali::Vector2 *result = 0 ;
32085
32086   arg1 = (Dali::LongPressGesture *)jarg1;
32087   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32088   jresult = (void *)result;
32089   return jresult;
32090 }
32091
32092
32093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32094   void * jresult ;
32095   Dali::WheelEvent *result = 0 ;
32096
32097   {
32098     try {
32099       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32100     } catch (std::out_of_range& e) {
32101       {
32102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32103       };
32104     } catch (std::exception& e) {
32105       {
32106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32107       };
32108     } catch (Dali::DaliException e) {
32109       {
32110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32111       };
32112     } catch (...) {
32113       {
32114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32115       };
32116     }
32117   }
32118
32119   jresult = (void *)result;
32120   return jresult;
32121 }
32122
32123
32124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32125   void * jresult ;
32126   Dali::WheelEvent::Type arg1 ;
32127   int arg2 ;
32128   unsigned int arg3 ;
32129   Dali::Vector2 arg4 ;
32130   int arg5 ;
32131   unsigned int arg6 ;
32132   Dali::Vector2 *argp4 ;
32133   Dali::WheelEvent *result = 0 ;
32134
32135   arg1 = (Dali::WheelEvent::Type)jarg1;
32136   arg2 = (int)jarg2;
32137   arg3 = (unsigned int)jarg3;
32138   argp4 = (Dali::Vector2 *)jarg4;
32139   if (!argp4) {
32140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32141     return 0;
32142   }
32143   arg4 = *argp4;
32144   arg5 = (int)jarg5;
32145   arg6 = (unsigned int)jarg6;
32146   {
32147     try {
32148       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32149     } catch (std::out_of_range& e) {
32150       {
32151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32152       };
32153     } catch (std::exception& e) {
32154       {
32155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32156       };
32157     } catch (Dali::DaliException e) {
32158       {
32159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32160       };
32161     } catch (...) {
32162       {
32163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32164       };
32165     }
32166   }
32167
32168   jresult = (void *)result;
32169   return jresult;
32170 }
32171
32172
32173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32174   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32175
32176   arg1 = (Dali::WheelEvent *)jarg1;
32177   {
32178     try {
32179       delete arg1;
32180     } catch (std::out_of_range& e) {
32181       {
32182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32183       };
32184     } catch (std::exception& e) {
32185       {
32186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32187       };
32188     } catch (Dali::DaliException e) {
32189       {
32190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32191       };
32192     } catch (...) {
32193       {
32194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32195       };
32196     }
32197   }
32198
32199 }
32200
32201
32202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32203   unsigned int jresult ;
32204   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32205   bool result;
32206
32207   arg1 = (Dali::WheelEvent *)jarg1;
32208   {
32209     try {
32210       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32211     } catch (std::out_of_range& e) {
32212       {
32213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32214       };
32215     } catch (std::exception& e) {
32216       {
32217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32218       };
32219     } catch (Dali::DaliException e) {
32220       {
32221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32222       };
32223     } catch (...) {
32224       {
32225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32226       };
32227     }
32228   }
32229
32230   jresult = result;
32231   return jresult;
32232 }
32233
32234
32235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32236   unsigned int jresult ;
32237   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32238   bool result;
32239
32240   arg1 = (Dali::WheelEvent *)jarg1;
32241   {
32242     try {
32243       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32244     } catch (std::out_of_range& e) {
32245       {
32246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32247       };
32248     } catch (std::exception& e) {
32249       {
32250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32251       };
32252     } catch (Dali::DaliException e) {
32253       {
32254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32255       };
32256     } catch (...) {
32257       {
32258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32259       };
32260     }
32261   }
32262
32263   jresult = result;
32264   return jresult;
32265 }
32266
32267
32268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32269   unsigned int jresult ;
32270   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32271   bool result;
32272
32273   arg1 = (Dali::WheelEvent *)jarg1;
32274   {
32275     try {
32276       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32277     } catch (std::out_of_range& e) {
32278       {
32279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32280       };
32281     } catch (std::exception& e) {
32282       {
32283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32284       };
32285     } catch (Dali::DaliException e) {
32286       {
32287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32288       };
32289     } catch (...) {
32290       {
32291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32292       };
32293     }
32294   }
32295
32296   jresult = result;
32297   return jresult;
32298 }
32299
32300
32301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32302   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32303   Dali::WheelEvent::Type arg2 ;
32304
32305   arg1 = (Dali::WheelEvent *)jarg1;
32306   arg2 = (Dali::WheelEvent::Type)jarg2;
32307   if (arg1) (arg1)->type = arg2;
32308 }
32309
32310
32311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32312   int jresult ;
32313   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32314   Dali::WheelEvent::Type result;
32315
32316   arg1 = (Dali::WheelEvent *)jarg1;
32317   result = (Dali::WheelEvent::Type) ((arg1)->type);
32318   jresult = (int)result;
32319   return jresult;
32320 }
32321
32322
32323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32324   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32325   int arg2 ;
32326
32327   arg1 = (Dali::WheelEvent *)jarg1;
32328   arg2 = (int)jarg2;
32329   if (arg1) (arg1)->direction = arg2;
32330 }
32331
32332
32333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32334   int jresult ;
32335   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32336   int result;
32337
32338   arg1 = (Dali::WheelEvent *)jarg1;
32339   result = (int) ((arg1)->direction);
32340   jresult = result;
32341   return jresult;
32342 }
32343
32344
32345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32346   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32347   unsigned int arg2 ;
32348
32349   arg1 = (Dali::WheelEvent *)jarg1;
32350   arg2 = (unsigned int)jarg2;
32351   if (arg1) (arg1)->modifiers = arg2;
32352 }
32353
32354
32355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32356   unsigned int jresult ;
32357   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32358   unsigned int result;
32359
32360   arg1 = (Dali::WheelEvent *)jarg1;
32361   result = (unsigned int) ((arg1)->modifiers);
32362   jresult = result;
32363   return jresult;
32364 }
32365
32366
32367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32368   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32369   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32370
32371   arg1 = (Dali::WheelEvent *)jarg1;
32372   arg2 = (Dali::Vector2 *)jarg2;
32373   if (arg1) (arg1)->point = *arg2;
32374 }
32375
32376
32377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32378   void * jresult ;
32379   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32380   Dali::Vector2 *result = 0 ;
32381
32382   arg1 = (Dali::WheelEvent *)jarg1;
32383   result = (Dali::Vector2 *)& ((arg1)->point);
32384   jresult = (void *)result;
32385   return jresult;
32386 }
32387
32388
32389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32390   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32391   int arg2 ;
32392
32393   arg1 = (Dali::WheelEvent *)jarg1;
32394   arg2 = (int)jarg2;
32395   if (arg1) (arg1)->z = arg2;
32396 }
32397
32398
32399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32400   int jresult ;
32401   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32402   int result;
32403
32404   arg1 = (Dali::WheelEvent *)jarg1;
32405   result = (int) ((arg1)->z);
32406   jresult = result;
32407   return jresult;
32408 }
32409
32410
32411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32412   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32413   unsigned int arg2 ;
32414
32415   arg1 = (Dali::WheelEvent *)jarg1;
32416   arg2 = (unsigned int)jarg2;
32417   if (arg1) (arg1)->timeStamp = arg2;
32418 }
32419
32420
32421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32422   unsigned int jresult ;
32423   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32424   unsigned int result;
32425
32426   arg1 = (Dali::WheelEvent *)jarg1;
32427   result = (unsigned int) ((arg1)->timeStamp);
32428   jresult = result;
32429   return jresult;
32430 }
32431
32432 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32433   char * jresult ;
32434   Dali::KeyEvent *arg1 = 0 ;
32435   std::string result;
32436
32437   arg1 = (Dali::KeyEvent *)jarg1;
32438   if (!arg1) {
32439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32440     return 0;
32441   }
32442   {
32443     try {
32444       result = arg1->GetDeviceName();
32445     } catch (std::out_of_range& e) {
32446       {
32447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32448       };
32449     } catch (std::exception& e) {
32450       {
32451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32452       };
32453     } catch (Dali::DaliException e) {
32454       {
32455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32456       };
32457     } catch (...) {
32458       {
32459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32460       };
32461     }
32462   }
32463
32464   jresult = SWIG_csharp_string_callback((&result)->c_str());
32465   return jresult;
32466 }
32467
32468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32469   int jresult ;
32470   Dali::KeyEvent *arg1 = 0 ;
32471   Dali::Device::Class::Type result;
32472
32473   arg1 = (Dali::KeyEvent *)jarg1;
32474   if (!arg1) {
32475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32476     return 0;
32477   }
32478   {
32479     try {
32480       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32481     } catch (std::out_of_range& e) {
32482       {
32483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32484       };
32485     } catch (std::exception& e) {
32486       {
32487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32488       };
32489     } catch (Dali::DaliException e) {
32490       {
32491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32492       };
32493     } catch (...) {
32494       {
32495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32496       };
32497     }
32498   }
32499
32500   jresult = (int)result;
32501   return jresult;
32502 }
32503
32504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32505   int jresult ;
32506   Dali::KeyEvent *arg1 = 0 ;
32507   Dali::Device::Subclass::Type result;
32508
32509   arg1 = (Dali::KeyEvent *)jarg1;
32510   if (!arg1) {
32511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32512     return 0;
32513   }
32514   {
32515     try {
32516       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32517     } catch (std::out_of_range& e) {
32518       {
32519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32520       };
32521     } catch (std::exception& e) {
32522       {
32523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32524       };
32525     } catch (Dali::DaliException e) {
32526       {
32527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32528       };
32529     } catch (...) {
32530       {
32531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32532       };
32533     }
32534   }
32535
32536   jresult = (int)result;
32537   return jresult;
32538 }
32539
32540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32541   Dali::Actor arg1 ;
32542   Dali::Actor *argp1 ;
32543
32544   argp1 = (Dali::Actor *)jarg1;
32545   if (!argp1) {
32546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32547     return ;
32548   }
32549   arg1 = *argp1;
32550   {
32551     try {
32552       arg1.Raise();
32553     } catch (std::out_of_range& e) {
32554       {
32555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32556       };
32557     } catch (std::exception& e) {
32558       {
32559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32560       };
32561     } catch (Dali::DaliException e) {
32562       {
32563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32564       };
32565     } catch (...) {
32566       {
32567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32568       };
32569     }
32570   }
32571
32572 }
32573
32574
32575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32576   Dali::Actor arg1 ;
32577   Dali::Actor *argp1 ;
32578
32579   argp1 = (Dali::Actor *)jarg1;
32580   if (!argp1) {
32581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32582     return ;
32583   }
32584   arg1 = *argp1;
32585   {
32586     try {
32587       arg1.Lower();
32588     } catch (std::out_of_range& e) {
32589       {
32590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32591       };
32592     } catch (std::exception& e) {
32593       {
32594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32595       };
32596     } catch (Dali::DaliException e) {
32597       {
32598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32599       };
32600     } catch (...) {
32601       {
32602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32603       };
32604     }
32605   }
32606
32607 }
32608
32609
32610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32611   Dali::Actor arg1 ;
32612   Dali::Actor *argp1 ;
32613
32614   argp1 = (Dali::Actor *)jarg1;
32615   if (!argp1) {
32616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32617     return ;
32618   }
32619   arg1 = *argp1;
32620   {
32621     try {
32622       arg1.RaiseToTop();
32623     } catch (std::out_of_range& e) {
32624       {
32625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32626       };
32627     } catch (std::exception& e) {
32628       {
32629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32630       };
32631     } catch (Dali::DaliException e) {
32632       {
32633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32634       };
32635     } catch (...) {
32636       {
32637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32638       };
32639     }
32640   }
32641
32642 }
32643
32644
32645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32646   Dali::Actor arg1 ;
32647   Dali::Actor *argp1 ;
32648
32649   argp1 = (Dali::Actor *)jarg1;
32650   if (!argp1) {
32651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32652     return ;
32653   }
32654   arg1 = *argp1;
32655   {
32656     try {
32657       arg1.LowerToBottom();
32658     } catch (std::out_of_range& e) {
32659       {
32660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32661       };
32662     } catch (std::exception& e) {
32663       {
32664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32665       };
32666     } catch (Dali::DaliException e) {
32667       {
32668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32669       };
32670     } catch (...) {
32671       {
32672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32673       };
32674     }
32675   }
32676
32677 }
32678
32679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32680   Dali::Actor arg1 ;
32681   Dali::Actor arg2 ;
32682   Dali::Actor *argp1 ;
32683   Dali::Actor *argp2 ;
32684
32685   argp1 = (Dali::Actor *)jarg1;
32686   if (!argp1) {
32687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32688     return ;
32689   }
32690   arg1 = *argp1;
32691   argp2 = (Dali::Actor *)jarg2;
32692   if (!argp2) {
32693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32694     return ;
32695   }
32696   arg2 = *argp2;
32697   {
32698     try {
32699       arg1.RaiseAbove(arg2);
32700     } catch (std::out_of_range& e) {
32701       {
32702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32703       };
32704     } catch (std::exception& e) {
32705       {
32706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32707       };
32708     } catch (Dali::DaliException e) {
32709       {
32710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32711       };
32712     } catch (...) {
32713       {
32714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32715       };
32716     }
32717   }
32718
32719 }
32720
32721
32722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32723   Dali::Actor arg1 ;
32724   Dali::Actor arg2 ;
32725   Dali::Actor *argp1 ;
32726   Dali::Actor *argp2 ;
32727
32728   argp1 = (Dali::Actor *)jarg1;
32729   if (!argp1) {
32730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32731     return ;
32732   }
32733   arg1 = *argp1;
32734   argp2 = (Dali::Actor *)jarg2;
32735   if (!argp2) {
32736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32737     return ;
32738   }
32739   arg2 = *argp2;
32740   {
32741     try {
32742       arg1.LowerBelow(arg2);
32743     } catch (std::out_of_range& e) {
32744       {
32745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32746       };
32747     } catch (std::exception& e) {
32748       {
32749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32750       };
32751     } catch (Dali::DaliException e) {
32752       {
32753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32754       };
32755     } catch (...) {
32756       {
32757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32758       };
32759     }
32760   }
32761
32762 }
32763
32764
32765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32766   void * jresult ;
32767   Dali::Actor arg1 ;
32768   Dali::Actor *argp1 ;
32769   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32770
32771   argp1 = (Dali::Actor *)jarg1;
32772   if (!argp1) {
32773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32774     return 0;
32775   }
32776   arg1 = *argp1;
32777   {
32778     try {
32779       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32780     } catch (std::out_of_range& e) {
32781       {
32782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32783       };
32784     } catch (std::exception& e) {
32785       {
32786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32787       };
32788     } catch (Dali::DaliException e) {
32789       {
32790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32791       };
32792     } catch (...) {
32793       {
32794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32795       };
32796     }
32797   }
32798
32799   jresult = (void *)result;
32800   return jresult;
32801 }
32802
32803
32804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32805   void * jresult ;
32806   Dali::Actor *arg1 ;
32807   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32808
32809   arg1 = (Dali::Actor *)jarg1;
32810   {
32811     try {
32812       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32813     } catch (std::out_of_range& e) {
32814       {
32815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32816       };
32817     } catch (std::exception& e) {
32818       {
32819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32820       };
32821     } catch (Dali::DaliException e) {
32822       {
32823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32824       };
32825     } catch (...) {
32826       {
32827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32828       };
32829     }
32830   }
32831
32832   jresult = (void *)result;
32833   return jresult;
32834 }
32835
32836
32837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32838   int jresult ;
32839   int result;
32840
32841   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32842   jresult = (int)result;
32843   return jresult;
32844 }
32845
32846
32847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32848   int jresult ;
32849   int result;
32850
32851   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32852   jresult = (int)result;
32853   return jresult;
32854 }
32855
32856
32857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32858   int jresult ;
32859   int result;
32860
32861   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32862   jresult = (int)result;
32863   return jresult;
32864 }
32865
32866
32867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32868   int jresult ;
32869   int result;
32870
32871   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32872   jresult = (int)result;
32873   return jresult;
32874 }
32875
32876
32877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32878   int jresult ;
32879   int result;
32880
32881   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32882   jresult = (int)result;
32883   return jresult;
32884 }
32885
32886
32887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32888   int jresult ;
32889   int result;
32890
32891   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32892   jresult = (int)result;
32893   return jresult;
32894 }
32895
32896
32897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32898   int jresult ;
32899   int result;
32900
32901   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32902   jresult = (int)result;
32903   return jresult;
32904 }
32905
32906
32907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32908   int jresult ;
32909   int result;
32910
32911   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32912   jresult = (int)result;
32913   return jresult;
32914 }
32915
32916
32917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32918   int jresult ;
32919   int result;
32920
32921   result = (int)Dali::Actor::Property::SIZE;
32922   jresult = (int)result;
32923   return jresult;
32924 }
32925
32926
32927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32928   int jresult ;
32929   int result;
32930
32931   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32932   jresult = (int)result;
32933   return jresult;
32934 }
32935
32936
32937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32938   int jresult ;
32939   int result;
32940
32941   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32942   jresult = (int)result;
32943   return jresult;
32944 }
32945
32946
32947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32948   int jresult ;
32949   int result;
32950
32951   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32952   jresult = (int)result;
32953   return jresult;
32954 }
32955
32956
32957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32958   int jresult ;
32959   int result;
32960
32961   result = (int)Dali::Actor::Property::POSITION;
32962   jresult = (int)result;
32963   return jresult;
32964 }
32965
32966
32967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32968   int jresult ;
32969   int result;
32970
32971   result = (int)Dali::Actor::Property::POSITION_X;
32972   jresult = (int)result;
32973   return jresult;
32974 }
32975
32976
32977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32978   int jresult ;
32979   int result;
32980
32981   result = (int)Dali::Actor::Property::POSITION_Y;
32982   jresult = (int)result;
32983   return jresult;
32984 }
32985
32986
32987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32988   int jresult ;
32989   int result;
32990
32991   result = (int)Dali::Actor::Property::POSITION_Z;
32992   jresult = (int)result;
32993   return jresult;
32994 }
32995
32996
32997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32998   int jresult ;
32999   int result;
33000
33001   result = (int)Dali::Actor::Property::WORLD_POSITION;
33002   jresult = (int)result;
33003   return jresult;
33004 }
33005
33006
33007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33008   int jresult ;
33009   int result;
33010
33011   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33012   jresult = (int)result;
33013   return jresult;
33014 }
33015
33016
33017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33018   int jresult ;
33019   int result;
33020
33021   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33022   jresult = (int)result;
33023   return jresult;
33024 }
33025
33026
33027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33028   int jresult ;
33029   int result;
33030
33031   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33032   jresult = (int)result;
33033   return jresult;
33034 }
33035
33036
33037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33038   int jresult ;
33039   int result;
33040
33041   result = (int)Dali::Actor::Property::ORIENTATION;
33042   jresult = (int)result;
33043   return jresult;
33044 }
33045
33046
33047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33048   int jresult ;
33049   int result;
33050
33051   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33052   jresult = (int)result;
33053   return jresult;
33054 }
33055
33056
33057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33058   int jresult ;
33059   int result;
33060
33061   result = (int)Dali::Actor::Property::SCALE;
33062   jresult = (int)result;
33063   return jresult;
33064 }
33065
33066
33067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33068   int jresult ;
33069   int result;
33070
33071   result = (int)Dali::Actor::Property::SCALE_X;
33072   jresult = (int)result;
33073   return jresult;
33074 }
33075
33076
33077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33078   int jresult ;
33079   int result;
33080
33081   result = (int)Dali::Actor::Property::SCALE_Y;
33082   jresult = (int)result;
33083   return jresult;
33084 }
33085
33086
33087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33088   int jresult ;
33089   int result;
33090
33091   result = (int)Dali::Actor::Property::SCALE_Z;
33092   jresult = (int)result;
33093   return jresult;
33094 }
33095
33096
33097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33098   int jresult ;
33099   int result;
33100
33101   result = (int)Dali::Actor::Property::WORLD_SCALE;
33102   jresult = (int)result;
33103   return jresult;
33104 }
33105
33106
33107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33108   int jresult ;
33109   int result;
33110
33111   result = (int)Dali::Actor::Property::VISIBLE;
33112   jresult = (int)result;
33113   return jresult;
33114 }
33115
33116
33117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33118   int jresult ;
33119   int result;
33120
33121   result = (int)Dali::Actor::Property::COLOR;
33122   jresult = (int)result;
33123   return jresult;
33124 }
33125
33126
33127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33128   int jresult ;
33129   int result;
33130
33131   result = (int)Dali::Actor::Property::COLOR_RED;
33132   jresult = (int)result;
33133   return jresult;
33134 }
33135
33136
33137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33138   int jresult ;
33139   int result;
33140
33141   result = (int)Dali::Actor::Property::COLOR_GREEN;
33142   jresult = (int)result;
33143   return jresult;
33144 }
33145
33146
33147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33148   int jresult ;
33149   int result;
33150
33151   result = (int)Dali::Actor::Property::COLOR_BLUE;
33152   jresult = (int)result;
33153   return jresult;
33154 }
33155
33156
33157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33158   int jresult ;
33159   int result;
33160
33161   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33162   jresult = (int)result;
33163   return jresult;
33164 }
33165
33166
33167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33168   int jresult ;
33169   int result;
33170
33171   result = (int)Dali::Actor::Property::WORLD_COLOR;
33172   jresult = (int)result;
33173   return jresult;
33174 }
33175
33176
33177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33178   int jresult ;
33179   int result;
33180
33181   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33182   jresult = (int)result;
33183   return jresult;
33184 }
33185
33186
33187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33188   int jresult ;
33189   int result;
33190
33191   result = (int)Dali::Actor::Property::NAME;
33192   jresult = (int)result;
33193   return jresult;
33194 }
33195
33196
33197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33198   int jresult ;
33199   int result;
33200
33201   result = (int)Dali::Actor::Property::SENSITIVE;
33202   jresult = (int)result;
33203   return jresult;
33204 }
33205
33206
33207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33208   int jresult ;
33209   int result;
33210
33211   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33212   jresult = (int)result;
33213   return jresult;
33214 }
33215
33216
33217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33218   int jresult ;
33219   int result;
33220
33221   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33222   jresult = (int)result;
33223   return jresult;
33224 }
33225
33226
33227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33228   int jresult ;
33229   int result;
33230
33231   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33232   jresult = (int)result;
33233   return jresult;
33234 }
33235
33236
33237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33238   int jresult ;
33239   int result;
33240
33241   result = (int)Dali::Actor::Property::COLOR_MODE;
33242   jresult = (int)result;
33243   return jresult;
33244 }
33245
33246
33247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33248   int jresult ;
33249   int result;
33250
33251   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33252   jresult = (int)result;
33253   return jresult;
33254 }
33255
33256
33257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33258   int jresult ;
33259   int result;
33260
33261   result = (int)Dali::Actor::Property::DRAW_MODE;
33262   jresult = (int)result;
33263   return jresult;
33264 }
33265
33266
33267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33268   int jresult ;
33269   int result;
33270
33271   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33272   jresult = (int)result;
33273   return jresult;
33274 }
33275
33276
33277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33278   int jresult ;
33279   int result;
33280
33281   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33282   jresult = (int)result;
33283   return jresult;
33284 }
33285
33286
33287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33288   int jresult ;
33289   int result;
33290
33291   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33292   jresult = (int)result;
33293   return jresult;
33294 }
33295
33296
33297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33298   int jresult ;
33299   int result;
33300
33301   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33302   jresult = (int)result;
33303   return jresult;
33304 }
33305
33306
33307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33308   int jresult ;
33309   int result;
33310
33311   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33312   jresult = (int)result;
33313   return jresult;
33314 }
33315
33316
33317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33318   int jresult ;
33319   int result;
33320
33321   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33322   jresult = (int)result;
33323   return jresult;
33324 }
33325
33326
33327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33328   int jresult ;
33329   int result;
33330
33331   result = (int)Dali::Actor::Property::PADDING;
33332   jresult = (int)result;
33333   return jresult;
33334 }
33335
33336
33337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33338   int jresult ;
33339   int result;
33340
33341   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33342   jresult = (int)result;
33343   return jresult;
33344 }
33345
33346
33347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33348   int jresult ;
33349   int result;
33350
33351   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33352   jresult = (int)result;
33353   return jresult;
33354 }
33355
33356
33357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33358   int jresult ;
33359   int result;
33360
33361   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33362   jresult = (int)result;
33363   return jresult;
33364 }
33365
33366
33367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33368   int jresult ;
33369   int result;
33370
33371   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33372   jresult = (int)result;
33373   return jresult;
33374 }
33375
33376
33377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33378   void * jresult ;
33379   Dali::Actor::Property *result = 0 ;
33380
33381   {
33382     try {
33383       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33384     } catch (std::out_of_range& e) {
33385       {
33386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33387       };
33388     } catch (std::exception& e) {
33389       {
33390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33391       };
33392     } catch (Dali::DaliException e) {
33393       {
33394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33395       };
33396     } catch (...) {
33397       {
33398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33399       };
33400     }
33401   }
33402
33403   jresult = (void *)result;
33404   return jresult;
33405 }
33406
33407
33408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33409   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33410
33411   arg1 = (Dali::Actor::Property *)jarg1;
33412   {
33413     try {
33414       delete arg1;
33415     } catch (std::out_of_range& e) {
33416       {
33417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33418       };
33419     } catch (std::exception& e) {
33420       {
33421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33422       };
33423     } catch (Dali::DaliException e) {
33424       {
33425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33426       };
33427     } catch (...) {
33428       {
33429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33430       };
33431     }
33432   }
33433
33434 }
33435
33436
33437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33438   void * jresult ;
33439   Dali::Actor *result = 0 ;
33440
33441   {
33442     try {
33443       result = (Dali::Actor *)new Dali::Actor();
33444     } catch (std::out_of_range& e) {
33445       {
33446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33447       };
33448     } catch (std::exception& e) {
33449       {
33450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33451       };
33452     } catch (Dali::DaliException e) {
33453       {
33454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33455       };
33456     } catch (...) {
33457       {
33458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33459       };
33460     }
33461   }
33462
33463   jresult = (void *)result;
33464   return jresult;
33465 }
33466
33467
33468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33469   void * jresult ;
33470   Dali::Actor result;
33471
33472   {
33473     try {
33474       result = Dali::Actor::New();
33475     } catch (std::out_of_range& e) {
33476       {
33477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33478       };
33479     } catch (std::exception& e) {
33480       {
33481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33482       };
33483     } catch (Dali::DaliException e) {
33484       {
33485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33486       };
33487     } catch (...) {
33488       {
33489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33490       };
33491     }
33492   }
33493
33494   jresult = new Dali::Actor((const Dali::Actor &)result);
33495   return jresult;
33496 }
33497
33498
33499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33500   void * jresult ;
33501   Dali::BaseHandle arg1 ;
33502   Dali::BaseHandle *argp1 ;
33503   Dali::Actor result;
33504
33505   argp1 = (Dali::BaseHandle *)jarg1;
33506   if (!argp1) {
33507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33508     return 0;
33509   }
33510   arg1 = *argp1;
33511   {
33512     try {
33513       result = Dali::Actor::DownCast(arg1);
33514     } catch (std::out_of_range& e) {
33515       {
33516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33517       };
33518     } catch (std::exception& e) {
33519       {
33520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33521       };
33522     } catch (Dali::DaliException e) {
33523       {
33524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33525       };
33526     } catch (...) {
33527       {
33528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33529       };
33530     }
33531   }
33532
33533   jresult = new Dali::Actor((const Dali::Actor &)result);
33534   return jresult;
33535 }
33536
33537
33538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33539   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33540
33541   arg1 = (Dali::Actor *)jarg1;
33542   {
33543     try {
33544       delete arg1;
33545     } catch (std::out_of_range& e) {
33546       {
33547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33548       };
33549     } catch (std::exception& e) {
33550       {
33551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33552       };
33553     } catch (Dali::DaliException e) {
33554       {
33555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33556       };
33557     } catch (...) {
33558       {
33559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33560       };
33561     }
33562   }
33563
33564 }
33565
33566
33567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33568   void * jresult ;
33569   Dali::Actor *arg1 = 0 ;
33570   Dali::Actor *result = 0 ;
33571
33572   arg1 = (Dali::Actor *)jarg1;
33573   if (!arg1) {
33574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33575     return 0;
33576   }
33577   {
33578     try {
33579       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33580     } catch (std::out_of_range& e) {
33581       {
33582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33583       };
33584     } catch (std::exception& e) {
33585       {
33586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33587       };
33588     } catch (Dali::DaliException e) {
33589       {
33590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33591       };
33592     } catch (...) {
33593       {
33594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33595       };
33596     }
33597   }
33598
33599   jresult = (void *)result;
33600   return jresult;
33601 }
33602
33603
33604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33605   void * jresult ;
33606   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33607   Dali::Actor *arg2 = 0 ;
33608   Dali::Actor *result = 0 ;
33609
33610   arg1 = (Dali::Actor *)jarg1;
33611   arg2 = (Dali::Actor *)jarg2;
33612   if (!arg2) {
33613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33614     return 0;
33615   }
33616   {
33617     try {
33618       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33619     } catch (std::out_of_range& e) {
33620       {
33621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33622       };
33623     } catch (std::exception& e) {
33624       {
33625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33626       };
33627     } catch (Dali::DaliException e) {
33628       {
33629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33630       };
33631     } catch (...) {
33632       {
33633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33634       };
33635     }
33636   }
33637
33638   jresult = (void *)result;
33639   return jresult;
33640 }
33641
33642
33643 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33644   char * jresult ;
33645   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33646   std::string *result = 0 ;
33647
33648   arg1 = (Dali::Actor *)jarg1;
33649   {
33650     try {
33651       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33652     } catch (std::out_of_range& e) {
33653       {
33654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33655       };
33656     } catch (std::exception& e) {
33657       {
33658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33659       };
33660     } catch (Dali::DaliException e) {
33661       {
33662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33663       };
33664     } catch (...) {
33665       {
33666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33667       };
33668     }
33669   }
33670
33671   jresult = SWIG_csharp_string_callback(result->c_str());
33672   return jresult;
33673 }
33674
33675
33676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33677   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33678   std::string *arg2 = 0 ;
33679
33680   arg1 = (Dali::Actor *)jarg1;
33681   if (!jarg2) {
33682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33683     return ;
33684   }
33685   std::string arg2_str(jarg2);
33686   arg2 = &arg2_str;
33687   {
33688     try {
33689       (arg1)->SetName((std::string const &)*arg2);
33690     } catch (std::out_of_range& e) {
33691       {
33692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33693       };
33694     } catch (std::exception& e) {
33695       {
33696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33697       };
33698     } catch (Dali::DaliException e) {
33699       {
33700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33701       };
33702     } catch (...) {
33703       {
33704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33705       };
33706     }
33707   }
33708
33709
33710   //argout typemap for const std::string&
33711
33712 }
33713
33714
33715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33716   unsigned int jresult ;
33717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33718   unsigned int result;
33719
33720   arg1 = (Dali::Actor *)jarg1;
33721   {
33722     try {
33723       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33724     } catch (std::out_of_range& e) {
33725       {
33726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33727       };
33728     } catch (std::exception& e) {
33729       {
33730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33731       };
33732     } catch (Dali::DaliException e) {
33733       {
33734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33735       };
33736     } catch (...) {
33737       {
33738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33739       };
33740     }
33741   }
33742
33743   jresult = result;
33744   return jresult;
33745 }
33746
33747
33748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33749   unsigned int jresult ;
33750   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33751   bool result;
33752
33753   arg1 = (Dali::Actor *)jarg1;
33754   {
33755     try {
33756       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33757     } catch (std::out_of_range& e) {
33758       {
33759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33760       };
33761     } catch (std::exception& e) {
33762       {
33763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33764       };
33765     } catch (Dali::DaliException e) {
33766       {
33767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33768       };
33769     } catch (...) {
33770       {
33771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33772       };
33773     }
33774   }
33775
33776   jresult = result;
33777   return jresult;
33778 }
33779
33780
33781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33782   unsigned int jresult ;
33783   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33784   bool result;
33785
33786   arg1 = (Dali::Actor *)jarg1;
33787   {
33788     try {
33789       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33790     } catch (std::out_of_range& e) {
33791       {
33792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33793       };
33794     } catch (std::exception& e) {
33795       {
33796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33797       };
33798     } catch (Dali::DaliException e) {
33799       {
33800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33801       };
33802     } catch (...) {
33803       {
33804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33805       };
33806     }
33807   }
33808
33809   jresult = result;
33810   return jresult;
33811 }
33812
33813
33814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33815   unsigned int jresult ;
33816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33817   bool result;
33818
33819   arg1 = (Dali::Actor *)jarg1;
33820   {
33821     try {
33822       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33823     } catch (std::out_of_range& e) {
33824       {
33825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33826       };
33827     } catch (std::exception& e) {
33828       {
33829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33830       };
33831     } catch (Dali::DaliException e) {
33832       {
33833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33834       };
33835     } catch (...) {
33836       {
33837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33838       };
33839     }
33840   }
33841
33842   jresult = result;
33843   return jresult;
33844 }
33845
33846
33847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33848   void * jresult ;
33849   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33850   Dali::Layer result;
33851
33852   arg1 = (Dali::Actor *)jarg1;
33853   {
33854     try {
33855       result = (arg1)->GetLayer();
33856     } catch (std::out_of_range& e) {
33857       {
33858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33859       };
33860     } catch (std::exception& e) {
33861       {
33862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33863       };
33864     } catch (Dali::DaliException e) {
33865       {
33866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33867       };
33868     } catch (...) {
33869       {
33870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33871       };
33872     }
33873   }
33874
33875   jresult = new Dali::Layer((const Dali::Layer &)result);
33876   return jresult;
33877 }
33878
33879
33880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33881   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33882   Dali::Actor arg2 ;
33883   Dali::Actor *argp2 ;
33884
33885   arg1 = (Dali::Actor *)jarg1;
33886   argp2 = (Dali::Actor *)jarg2;
33887   if (!argp2) {
33888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33889     return ;
33890   }
33891   arg2 = *argp2;
33892   {
33893     try {
33894       (arg1)->Add(arg2);
33895     } catch (std::out_of_range& e) {
33896       {
33897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33898       };
33899     } catch (std::exception& e) {
33900       {
33901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33902       };
33903     } catch (Dali::DaliException e) {
33904       {
33905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33906       };
33907     } catch (...) {
33908       {
33909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33910       };
33911     }
33912   }
33913
33914 }
33915
33916
33917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33918   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33919   Dali::Actor arg2 ;
33920   Dali::Actor *argp2 ;
33921
33922   arg1 = (Dali::Actor *)jarg1;
33923   argp2 = (Dali::Actor *)jarg2;
33924   if (!argp2) {
33925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33926     return ;
33927   }
33928   arg2 = *argp2;
33929   {
33930     try {
33931       (arg1)->Remove(arg2);
33932     } catch (std::out_of_range& e) {
33933       {
33934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33935       };
33936     } catch (std::exception& e) {
33937       {
33938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33939       };
33940     } catch (Dali::DaliException e) {
33941       {
33942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33943       };
33944     } catch (...) {
33945       {
33946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33947       };
33948     }
33949   }
33950
33951 }
33952
33953
33954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33955   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33956
33957   arg1 = (Dali::Actor *)jarg1;
33958   {
33959     try {
33960       (arg1)->Unparent();
33961     } catch (std::out_of_range& e) {
33962       {
33963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33964       };
33965     } catch (std::exception& e) {
33966       {
33967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33968       };
33969     } catch (Dali::DaliException e) {
33970       {
33971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33972       };
33973     } catch (...) {
33974       {
33975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33976       };
33977     }
33978   }
33979
33980 }
33981
33982
33983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33984   unsigned int jresult ;
33985   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33986   unsigned int result;
33987
33988   arg1 = (Dali::Actor *)jarg1;
33989   {
33990     try {
33991       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33992     } catch (std::out_of_range& e) {
33993       {
33994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33995       };
33996     } catch (std::exception& e) {
33997       {
33998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33999       };
34000     } catch (Dali::DaliException e) {
34001       {
34002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34003       };
34004     } catch (...) {
34005       {
34006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34007       };
34008     }
34009   }
34010
34011   jresult = result;
34012   return jresult;
34013 }
34014
34015
34016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34017   void * jresult ;
34018   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34019   unsigned int arg2 ;
34020   Dali::Actor result;
34021
34022   arg1 = (Dali::Actor *)jarg1;
34023   arg2 = (unsigned int)jarg2;
34024   {
34025     try {
34026       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34027     } catch (std::out_of_range& e) {
34028       {
34029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34030       };
34031     } catch (std::exception& e) {
34032       {
34033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34034       };
34035     } catch (Dali::DaliException e) {
34036       {
34037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34038       };
34039     } catch (...) {
34040       {
34041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34042       };
34043     }
34044   }
34045
34046   jresult = new Dali::Actor((const Dali::Actor &)result);
34047   return jresult;
34048 }
34049
34050
34051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34052   void * jresult ;
34053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34054   std::string *arg2 = 0 ;
34055   Dali::Actor result;
34056
34057   arg1 = (Dali::Actor *)jarg1;
34058   if (!jarg2) {
34059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34060     return 0;
34061   }
34062   std::string arg2_str(jarg2);
34063   arg2 = &arg2_str;
34064   {
34065     try {
34066       result = (arg1)->FindChildByName((std::string const &)*arg2);
34067     } catch (std::out_of_range& e) {
34068       {
34069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34070       };
34071     } catch (std::exception& e) {
34072       {
34073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34074       };
34075     } catch (Dali::DaliException e) {
34076       {
34077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34078       };
34079     } catch (...) {
34080       {
34081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34082       };
34083     }
34084   }
34085
34086   jresult = new Dali::Actor((const Dali::Actor &)result);
34087
34088   //argout typemap for const std::string&
34089
34090   return jresult;
34091 }
34092
34093
34094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34095   void * jresult ;
34096   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34097   unsigned int arg2 ;
34098   Dali::Actor result;
34099
34100   arg1 = (Dali::Actor *)jarg1;
34101   arg2 = (unsigned int)jarg2;
34102   {
34103     try {
34104       result = (arg1)->FindChildById(arg2);
34105     } catch (std::out_of_range& e) {
34106       {
34107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34108       };
34109     } catch (std::exception& e) {
34110       {
34111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34112       };
34113     } catch (Dali::DaliException e) {
34114       {
34115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34116       };
34117     } catch (...) {
34118       {
34119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34120       };
34121     }
34122   }
34123
34124   jresult = new Dali::Actor((const Dali::Actor &)result);
34125   return jresult;
34126 }
34127
34128
34129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34130   void * jresult ;
34131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34132   Dali::Actor result;
34133
34134   arg1 = (Dali::Actor *)jarg1;
34135   {
34136     try {
34137       result = ((Dali::Actor const *)arg1)->GetParent();
34138     } catch (std::out_of_range& e) {
34139       {
34140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34141       };
34142     } catch (std::exception& e) {
34143       {
34144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34145       };
34146     } catch (Dali::DaliException e) {
34147       {
34148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34149       };
34150     } catch (...) {
34151       {
34152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34153       };
34154     }
34155   }
34156
34157   jresult = new Dali::Actor((const Dali::Actor &)result);
34158   return jresult;
34159 }
34160
34161
34162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34163   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34164   Dali::Vector3 *arg2 = 0 ;
34165
34166   arg1 = (Dali::Actor *)jarg1;
34167   arg2 = (Dali::Vector3 *)jarg2;
34168   if (!arg2) {
34169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34170     return ;
34171   }
34172   {
34173     try {
34174       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34175     } catch (std::out_of_range& e) {
34176       {
34177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34178       };
34179     } catch (std::exception& e) {
34180       {
34181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34182       };
34183     } catch (Dali::DaliException e) {
34184       {
34185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34186       };
34187     } catch (...) {
34188       {
34189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34190       };
34191     }
34192   }
34193
34194 }
34195
34196
34197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34198   void * jresult ;
34199   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34200   Dali::Vector3 result;
34201
34202   arg1 = (Dali::Actor *)jarg1;
34203   {
34204     try {
34205       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34206     } catch (std::out_of_range& e) {
34207       {
34208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34209       };
34210     } catch (std::exception& e) {
34211       {
34212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34213       };
34214     } catch (Dali::DaliException e) {
34215       {
34216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34217       };
34218     } catch (...) {
34219       {
34220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34221       };
34222     }
34223   }
34224
34225   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34226   return jresult;
34227 }
34228
34229
34230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34231   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34232   Dali::Vector3 *arg2 = 0 ;
34233
34234   arg1 = (Dali::Actor *)jarg1;
34235   arg2 = (Dali::Vector3 *)jarg2;
34236   if (!arg2) {
34237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34238     return ;
34239   }
34240   {
34241     try {
34242       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34243     } catch (std::out_of_range& e) {
34244       {
34245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34246       };
34247     } catch (std::exception& e) {
34248       {
34249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34250       };
34251     } catch (Dali::DaliException e) {
34252       {
34253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34254       };
34255     } catch (...) {
34256       {
34257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34258       };
34259     }
34260   }
34261
34262 }
34263
34264
34265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34266   void * jresult ;
34267   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34268   Dali::Vector3 result;
34269
34270   arg1 = (Dali::Actor *)jarg1;
34271   {
34272     try {
34273       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34274     } catch (std::out_of_range& e) {
34275       {
34276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34277       };
34278     } catch (std::exception& e) {
34279       {
34280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34281       };
34282     } catch (Dali::DaliException e) {
34283       {
34284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34285       };
34286     } catch (...) {
34287       {
34288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34289       };
34290     }
34291   }
34292
34293   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34294   return jresult;
34295 }
34296
34297
34298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34299   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34300   float arg2 ;
34301   float arg3 ;
34302
34303   arg1 = (Dali::Actor *)jarg1;
34304   arg2 = (float)jarg2;
34305   arg3 = (float)jarg3;
34306   {
34307     try {
34308       (arg1)->SetSize(arg2,arg3);
34309     } catch (std::out_of_range& e) {
34310       {
34311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34312       };
34313     } catch (std::exception& e) {
34314       {
34315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34316       };
34317     } catch (Dali::DaliException e) {
34318       {
34319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34320       };
34321     } catch (...) {
34322       {
34323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34324       };
34325     }
34326   }
34327
34328 }
34329
34330
34331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34332   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34333   float arg2 ;
34334   float arg3 ;
34335   float arg4 ;
34336
34337   arg1 = (Dali::Actor *)jarg1;
34338   arg2 = (float)jarg2;
34339   arg3 = (float)jarg3;
34340   arg4 = (float)jarg4;
34341   {
34342     try {
34343       (arg1)->SetSize(arg2,arg3,arg4);
34344     } catch (std::out_of_range& e) {
34345       {
34346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34347       };
34348     } catch (std::exception& e) {
34349       {
34350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34351       };
34352     } catch (Dali::DaliException e) {
34353       {
34354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34355       };
34356     } catch (...) {
34357       {
34358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34359       };
34360     }
34361   }
34362
34363 }
34364
34365
34366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34367   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34368   Dali::Vector2 *arg2 = 0 ;
34369
34370   arg1 = (Dali::Actor *)jarg1;
34371   arg2 = (Dali::Vector2 *)jarg2;
34372   if (!arg2) {
34373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34374     return ;
34375   }
34376   {
34377     try {
34378       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34379     } catch (std::out_of_range& e) {
34380       {
34381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34382       };
34383     } catch (std::exception& e) {
34384       {
34385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34386       };
34387     } catch (Dali::DaliException e) {
34388       {
34389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34390       };
34391     } catch (...) {
34392       {
34393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34394       };
34395     }
34396   }
34397
34398 }
34399
34400
34401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34402   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34403   Dali::Vector3 *arg2 = 0 ;
34404
34405   arg1 = (Dali::Actor *)jarg1;
34406   arg2 = (Dali::Vector3 *)jarg2;
34407   if (!arg2) {
34408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34409     return ;
34410   }
34411   {
34412     try {
34413       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34414     } catch (std::out_of_range& e) {
34415       {
34416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34417       };
34418     } catch (std::exception& e) {
34419       {
34420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34421       };
34422     } catch (Dali::DaliException e) {
34423       {
34424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34425       };
34426     } catch (...) {
34427       {
34428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34429       };
34430     }
34431   }
34432
34433 }
34434
34435
34436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34437   void * jresult ;
34438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34439   Dali::Vector3 result;
34440
34441   arg1 = (Dali::Actor *)jarg1;
34442   {
34443     try {
34444       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34445     } catch (std::out_of_range& e) {
34446       {
34447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34448       };
34449     } catch (std::exception& e) {
34450       {
34451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34452       };
34453     } catch (Dali::DaliException e) {
34454       {
34455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34456       };
34457     } catch (...) {
34458       {
34459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34460       };
34461     }
34462   }
34463
34464   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34465   return jresult;
34466 }
34467
34468
34469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34470   void * jresult ;
34471   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34472   Dali::Vector3 result;
34473
34474   arg1 = (Dali::Actor *)jarg1;
34475   {
34476     try {
34477       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34478     } catch (std::out_of_range& e) {
34479       {
34480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34481       };
34482     } catch (std::exception& e) {
34483       {
34484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34485       };
34486     } catch (Dali::DaliException e) {
34487       {
34488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34489       };
34490     } catch (...) {
34491       {
34492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34493       };
34494     }
34495   }
34496
34497   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34498   return jresult;
34499 }
34500
34501
34502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34503   void * jresult ;
34504   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34505   Dali::Vector3 result;
34506
34507   arg1 = (Dali::Actor *)jarg1;
34508   {
34509     try {
34510       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34511     } catch (std::out_of_range& e) {
34512       {
34513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34514       };
34515     } catch (std::exception& e) {
34516       {
34517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34518       };
34519     } catch (Dali::DaliException e) {
34520       {
34521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34522       };
34523     } catch (...) {
34524       {
34525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34526       };
34527     }
34528   }
34529
34530   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34531   return jresult;
34532 }
34533
34534
34535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34537   float arg2 ;
34538   float arg3 ;
34539
34540   arg1 = (Dali::Actor *)jarg1;
34541   arg2 = (float)jarg2;
34542   arg3 = (float)jarg3;
34543   {
34544     try {
34545       (arg1)->SetPosition(arg2,arg3);
34546     } catch (std::out_of_range& e) {
34547       {
34548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34549       };
34550     } catch (std::exception& e) {
34551       {
34552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34553       };
34554     } catch (Dali::DaliException e) {
34555       {
34556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34557       };
34558     } catch (...) {
34559       {
34560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34561       };
34562     }
34563   }
34564
34565 }
34566
34567
34568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34569   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34570   float arg2 ;
34571   float arg3 ;
34572   float arg4 ;
34573
34574   arg1 = (Dali::Actor *)jarg1;
34575   arg2 = (float)jarg2;
34576   arg3 = (float)jarg3;
34577   arg4 = (float)jarg4;
34578   {
34579     try {
34580       (arg1)->SetPosition(arg2,arg3,arg4);
34581     } catch (std::out_of_range& e) {
34582       {
34583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34584       };
34585     } catch (std::exception& e) {
34586       {
34587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34588       };
34589     } catch (Dali::DaliException e) {
34590       {
34591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34592       };
34593     } catch (...) {
34594       {
34595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34596       };
34597     }
34598   }
34599
34600 }
34601
34602
34603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34604   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34605   Dali::Vector3 *arg2 = 0 ;
34606
34607   arg1 = (Dali::Actor *)jarg1;
34608   arg2 = (Dali::Vector3 *)jarg2;
34609   if (!arg2) {
34610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34611     return ;
34612   }
34613   {
34614     try {
34615       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34616     } catch (std::out_of_range& e) {
34617       {
34618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34619       };
34620     } catch (std::exception& e) {
34621       {
34622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34623       };
34624     } catch (Dali::DaliException e) {
34625       {
34626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34627       };
34628     } catch (...) {
34629       {
34630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34631       };
34632     }
34633   }
34634
34635 }
34636
34637
34638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34640   float arg2 ;
34641
34642   arg1 = (Dali::Actor *)jarg1;
34643   arg2 = (float)jarg2;
34644   {
34645     try {
34646       (arg1)->SetX(arg2);
34647     } catch (std::out_of_range& e) {
34648       {
34649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34650       };
34651     } catch (std::exception& e) {
34652       {
34653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34654       };
34655     } catch (Dali::DaliException e) {
34656       {
34657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34658       };
34659     } catch (...) {
34660       {
34661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34662       };
34663     }
34664   }
34665
34666 }
34667
34668
34669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34671   float arg2 ;
34672
34673   arg1 = (Dali::Actor *)jarg1;
34674   arg2 = (float)jarg2;
34675   {
34676     try {
34677       (arg1)->SetY(arg2);
34678     } catch (std::out_of_range& e) {
34679       {
34680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34681       };
34682     } catch (std::exception& e) {
34683       {
34684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34685       };
34686     } catch (Dali::DaliException e) {
34687       {
34688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34689       };
34690     } catch (...) {
34691       {
34692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34693       };
34694     }
34695   }
34696
34697 }
34698
34699
34700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34702   float arg2 ;
34703
34704   arg1 = (Dali::Actor *)jarg1;
34705   arg2 = (float)jarg2;
34706   {
34707     try {
34708       (arg1)->SetZ(arg2);
34709     } catch (std::out_of_range& e) {
34710       {
34711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34712       };
34713     } catch (std::exception& e) {
34714       {
34715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34716       };
34717     } catch (Dali::DaliException e) {
34718       {
34719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34720       };
34721     } catch (...) {
34722       {
34723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34724       };
34725     }
34726   }
34727
34728 }
34729
34730
34731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34732   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34733   Dali::Vector3 *arg2 = 0 ;
34734
34735   arg1 = (Dali::Actor *)jarg1;
34736   arg2 = (Dali::Vector3 *)jarg2;
34737   if (!arg2) {
34738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34739     return ;
34740   }
34741   {
34742     try {
34743       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34744     } catch (std::out_of_range& e) {
34745       {
34746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34747       };
34748     } catch (std::exception& e) {
34749       {
34750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34751       };
34752     } catch (Dali::DaliException e) {
34753       {
34754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34755       };
34756     } catch (...) {
34757       {
34758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34759       };
34760     }
34761   }
34762
34763 }
34764
34765
34766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34767   void * jresult ;
34768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34769   Dali::Vector3 result;
34770
34771   arg1 = (Dali::Actor *)jarg1;
34772   {
34773     try {
34774       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34775     } catch (std::out_of_range& e) {
34776       {
34777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34778       };
34779     } catch (std::exception& e) {
34780       {
34781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34782       };
34783     } catch (Dali::DaliException e) {
34784       {
34785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34786       };
34787     } catch (...) {
34788       {
34789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34790       };
34791     }
34792   }
34793
34794   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34795   return jresult;
34796 }
34797
34798
34799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34800   void * jresult ;
34801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34802   Dali::Vector3 result;
34803
34804   arg1 = (Dali::Actor *)jarg1;
34805   {
34806     try {
34807       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34808     } catch (std::out_of_range& e) {
34809       {
34810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34811       };
34812     } catch (std::exception& e) {
34813       {
34814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34815       };
34816     } catch (Dali::DaliException e) {
34817       {
34818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34819       };
34820     } catch (...) {
34821       {
34822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34823       };
34824     }
34825   }
34826
34827   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34828   return jresult;
34829 }
34830
34831
34832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34834   bool arg2 ;
34835
34836   arg1 = (Dali::Actor *)jarg1;
34837   arg2 = jarg2 ? true : false;
34838   {
34839     try {
34840       (arg1)->SetInheritPosition(arg2);
34841     } catch (std::out_of_range& e) {
34842       {
34843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34844       };
34845     } catch (std::exception& e) {
34846       {
34847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34848       };
34849     } catch (Dali::DaliException e) {
34850       {
34851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34852       };
34853     } catch (...) {
34854       {
34855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34856       };
34857     }
34858   }
34859
34860 }
34861
34862
34863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34864   int jresult ;
34865   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34866   Dali::PositionInheritanceMode result;
34867
34868   arg1 = (Dali::Actor *)jarg1;
34869   {
34870     try {
34871       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34872     } catch (std::out_of_range& e) {
34873       {
34874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34875       };
34876     } catch (std::exception& e) {
34877       {
34878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34879       };
34880     } catch (Dali::DaliException e) {
34881       {
34882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34883       };
34884     } catch (...) {
34885       {
34886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34887       };
34888     }
34889   }
34890
34891   jresult = (int)result;
34892   return jresult;
34893 }
34894
34895
34896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34897   unsigned int jresult ;
34898   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34899   bool result;
34900
34901   arg1 = (Dali::Actor *)jarg1;
34902   {
34903     try {
34904       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34905     } catch (std::out_of_range& e) {
34906       {
34907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34908       };
34909     } catch (std::exception& e) {
34910       {
34911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34912       };
34913     } catch (Dali::DaliException e) {
34914       {
34915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34916       };
34917     } catch (...) {
34918       {
34919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34920       };
34921     }
34922   }
34923
34924   jresult = result;
34925   return jresult;
34926 }
34927
34928
34929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34931   Dali::Degree *arg2 = 0 ;
34932   Dali::Vector3 *arg3 = 0 ;
34933
34934   arg1 = (Dali::Actor *)jarg1;
34935   arg2 = (Dali::Degree *)jarg2;
34936   if (!arg2) {
34937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34938     return ;
34939   }
34940   arg3 = (Dali::Vector3 *)jarg3;
34941   if (!arg3) {
34942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34943     return ;
34944   }
34945   {
34946     try {
34947       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34948     } catch (std::out_of_range& e) {
34949       {
34950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34951       };
34952     } catch (std::exception& e) {
34953       {
34954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34955       };
34956     } catch (Dali::DaliException e) {
34957       {
34958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34959       };
34960     } catch (...) {
34961       {
34962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34963       };
34964     }
34965   }
34966
34967 }
34968
34969
34970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34971   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34972   Dali::Radian *arg2 = 0 ;
34973   Dali::Vector3 *arg3 = 0 ;
34974
34975   arg1 = (Dali::Actor *)jarg1;
34976   arg2 = (Dali::Radian *)jarg2;
34977   if (!arg2) {
34978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34979     return ;
34980   }
34981   arg3 = (Dali::Vector3 *)jarg3;
34982   if (!arg3) {
34983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34984     return ;
34985   }
34986   {
34987     try {
34988       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34989     } catch (std::out_of_range& e) {
34990       {
34991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34992       };
34993     } catch (std::exception& e) {
34994       {
34995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34996       };
34997     } catch (Dali::DaliException e) {
34998       {
34999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35000       };
35001     } catch (...) {
35002       {
35003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35004       };
35005     }
35006   }
35007
35008 }
35009
35010
35011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35013   Dali::Quaternion *arg2 = 0 ;
35014
35015   arg1 = (Dali::Actor *)jarg1;
35016   arg2 = (Dali::Quaternion *)jarg2;
35017   if (!arg2) {
35018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35019     return ;
35020   }
35021   {
35022     try {
35023       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35024     } catch (std::out_of_range& e) {
35025       {
35026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35027       };
35028     } catch (std::exception& e) {
35029       {
35030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35031       };
35032     } catch (Dali::DaliException e) {
35033       {
35034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35035       };
35036     } catch (...) {
35037       {
35038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35039       };
35040     }
35041   }
35042
35043 }
35044
35045
35046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35048   Dali::Degree *arg2 = 0 ;
35049   Dali::Vector3 *arg3 = 0 ;
35050
35051   arg1 = (Dali::Actor *)jarg1;
35052   arg2 = (Dali::Degree *)jarg2;
35053   if (!arg2) {
35054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35055     return ;
35056   }
35057   arg3 = (Dali::Vector3 *)jarg3;
35058   if (!arg3) {
35059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35060     return ;
35061   }
35062   {
35063     try {
35064       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35065     } catch (std::out_of_range& e) {
35066       {
35067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35068       };
35069     } catch (std::exception& e) {
35070       {
35071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35072       };
35073     } catch (Dali::DaliException e) {
35074       {
35075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35076       };
35077     } catch (...) {
35078       {
35079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35080       };
35081     }
35082   }
35083
35084 }
35085
35086
35087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35088   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35089   Dali::Radian *arg2 = 0 ;
35090   Dali::Vector3 *arg3 = 0 ;
35091
35092   arg1 = (Dali::Actor *)jarg1;
35093   arg2 = (Dali::Radian *)jarg2;
35094   if (!arg2) {
35095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35096     return ;
35097   }
35098   arg3 = (Dali::Vector3 *)jarg3;
35099   if (!arg3) {
35100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35101     return ;
35102   }
35103   {
35104     try {
35105       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35106     } catch (std::out_of_range& e) {
35107       {
35108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35109       };
35110     } catch (std::exception& e) {
35111       {
35112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35113       };
35114     } catch (Dali::DaliException e) {
35115       {
35116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35117       };
35118     } catch (...) {
35119       {
35120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35121       };
35122     }
35123   }
35124
35125 }
35126
35127
35128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35129   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35130   Dali::Quaternion *arg2 = 0 ;
35131
35132   arg1 = (Dali::Actor *)jarg1;
35133   arg2 = (Dali::Quaternion *)jarg2;
35134   if (!arg2) {
35135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35136     return ;
35137   }
35138   {
35139     try {
35140       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35141     } catch (std::out_of_range& e) {
35142       {
35143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35144       };
35145     } catch (std::exception& e) {
35146       {
35147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35148       };
35149     } catch (Dali::DaliException e) {
35150       {
35151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35152       };
35153     } catch (...) {
35154       {
35155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35156       };
35157     }
35158   }
35159
35160 }
35161
35162
35163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35164   void * jresult ;
35165   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35166   Dali::Quaternion result;
35167
35168   arg1 = (Dali::Actor *)jarg1;
35169   {
35170     try {
35171       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35172     } catch (std::out_of_range& e) {
35173       {
35174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35175       };
35176     } catch (std::exception& e) {
35177       {
35178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35179       };
35180     } catch (Dali::DaliException e) {
35181       {
35182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35183       };
35184     } catch (...) {
35185       {
35186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35187       };
35188     }
35189   }
35190
35191   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35192   return jresult;
35193 }
35194
35195
35196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35197   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35198   bool arg2 ;
35199
35200   arg1 = (Dali::Actor *)jarg1;
35201   arg2 = jarg2 ? true : false;
35202   {
35203     try {
35204       (arg1)->SetInheritOrientation(arg2);
35205     } catch (std::out_of_range& e) {
35206       {
35207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35208       };
35209     } catch (std::exception& e) {
35210       {
35211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35212       };
35213     } catch (Dali::DaliException e) {
35214       {
35215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35216       };
35217     } catch (...) {
35218       {
35219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35220       };
35221     }
35222   }
35223
35224 }
35225
35226
35227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35228   unsigned int jresult ;
35229   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35230   bool result;
35231
35232   arg1 = (Dali::Actor *)jarg1;
35233   {
35234     try {
35235       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35236     } catch (std::out_of_range& e) {
35237       {
35238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35239       };
35240     } catch (std::exception& e) {
35241       {
35242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35243       };
35244     } catch (Dali::DaliException e) {
35245       {
35246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35247       };
35248     } catch (...) {
35249       {
35250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35251       };
35252     }
35253   }
35254
35255   jresult = result;
35256   return jresult;
35257 }
35258
35259
35260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35261   void * jresult ;
35262   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35263   Dali::Quaternion result;
35264
35265   arg1 = (Dali::Actor *)jarg1;
35266   {
35267     try {
35268       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35269     } catch (std::out_of_range& e) {
35270       {
35271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35272       };
35273     } catch (std::exception& e) {
35274       {
35275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35276       };
35277     } catch (Dali::DaliException e) {
35278       {
35279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35280       };
35281     } catch (...) {
35282       {
35283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35284       };
35285     }
35286   }
35287
35288   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35289   return jresult;
35290 }
35291
35292
35293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35295   float arg2 ;
35296
35297   arg1 = (Dali::Actor *)jarg1;
35298   arg2 = (float)jarg2;
35299   {
35300     try {
35301       (arg1)->SetScale(arg2);
35302     } catch (std::out_of_range& e) {
35303       {
35304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35305       };
35306     } catch (std::exception& e) {
35307       {
35308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35309       };
35310     } catch (Dali::DaliException e) {
35311       {
35312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35313       };
35314     } catch (...) {
35315       {
35316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35317       };
35318     }
35319   }
35320
35321 }
35322
35323
35324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35326   float arg2 ;
35327   float arg3 ;
35328   float arg4 ;
35329
35330   arg1 = (Dali::Actor *)jarg1;
35331   arg2 = (float)jarg2;
35332   arg3 = (float)jarg3;
35333   arg4 = (float)jarg4;
35334   {
35335     try {
35336       (arg1)->SetScale(arg2,arg3,arg4);
35337     } catch (std::out_of_range& e) {
35338       {
35339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (std::exception& e) {
35342       {
35343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35344       };
35345     } catch (Dali::DaliException e) {
35346       {
35347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35348       };
35349     } catch (...) {
35350       {
35351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35352       };
35353     }
35354   }
35355
35356 }
35357
35358
35359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35361   Dali::Vector3 *arg2 = 0 ;
35362
35363   arg1 = (Dali::Actor *)jarg1;
35364   arg2 = (Dali::Vector3 *)jarg2;
35365   if (!arg2) {
35366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35367     return ;
35368   }
35369   {
35370     try {
35371       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35372     } catch (std::out_of_range& e) {
35373       {
35374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35375       };
35376     } catch (std::exception& e) {
35377       {
35378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35379       };
35380     } catch (Dali::DaliException e) {
35381       {
35382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35383       };
35384     } catch (...) {
35385       {
35386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35387       };
35388     }
35389   }
35390
35391 }
35392
35393
35394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35396   Dali::Vector3 *arg2 = 0 ;
35397
35398   arg1 = (Dali::Actor *)jarg1;
35399   arg2 = (Dali::Vector3 *)jarg2;
35400   if (!arg2) {
35401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35402     return ;
35403   }
35404   {
35405     try {
35406       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35407     } catch (std::out_of_range& e) {
35408       {
35409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35410       };
35411     } catch (std::exception& e) {
35412       {
35413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35414       };
35415     } catch (Dali::DaliException e) {
35416       {
35417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35418       };
35419     } catch (...) {
35420       {
35421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35422       };
35423     }
35424   }
35425
35426 }
35427
35428
35429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35430   void * jresult ;
35431   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35432   Dali::Vector3 result;
35433
35434   arg1 = (Dali::Actor *)jarg1;
35435   {
35436     try {
35437       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35438     } catch (std::out_of_range& e) {
35439       {
35440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35441       };
35442     } catch (std::exception& e) {
35443       {
35444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35445       };
35446     } catch (Dali::DaliException e) {
35447       {
35448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35449       };
35450     } catch (...) {
35451       {
35452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35453       };
35454     }
35455   }
35456
35457   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35458   return jresult;
35459 }
35460
35461
35462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35463   void * jresult ;
35464   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35465   Dali::Vector3 result;
35466
35467   arg1 = (Dali::Actor *)jarg1;
35468   {
35469     try {
35470       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35471     } catch (std::out_of_range& e) {
35472       {
35473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35474       };
35475     } catch (std::exception& e) {
35476       {
35477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35478       };
35479     } catch (Dali::DaliException e) {
35480       {
35481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35482       };
35483     } catch (...) {
35484       {
35485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35486       };
35487     }
35488   }
35489
35490   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35491   return jresult;
35492 }
35493
35494
35495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35497   bool arg2 ;
35498
35499   arg1 = (Dali::Actor *)jarg1;
35500   arg2 = jarg2 ? true : false;
35501   {
35502     try {
35503       (arg1)->SetInheritScale(arg2);
35504     } catch (std::out_of_range& e) {
35505       {
35506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35507       };
35508     } catch (std::exception& e) {
35509       {
35510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35511       };
35512     } catch (Dali::DaliException e) {
35513       {
35514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35515       };
35516     } catch (...) {
35517       {
35518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35519       };
35520     }
35521   }
35522
35523 }
35524
35525
35526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35527   unsigned int jresult ;
35528   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35529   bool result;
35530
35531   arg1 = (Dali::Actor *)jarg1;
35532   {
35533     try {
35534       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35535     } catch (std::out_of_range& e) {
35536       {
35537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35538       };
35539     } catch (std::exception& e) {
35540       {
35541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35542       };
35543     } catch (Dali::DaliException e) {
35544       {
35545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35546       };
35547     } catch (...) {
35548       {
35549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35550       };
35551     }
35552   }
35553
35554   jresult = result;
35555   return jresult;
35556 }
35557
35558
35559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35560   void * jresult ;
35561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35562   Dali::Matrix result;
35563
35564   arg1 = (Dali::Actor *)jarg1;
35565   {
35566     try {
35567       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35568     } catch (std::out_of_range& e) {
35569       {
35570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35571       };
35572     } catch (std::exception& e) {
35573       {
35574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35575       };
35576     } catch (Dali::DaliException e) {
35577       {
35578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35579       };
35580     } catch (...) {
35581       {
35582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35583       };
35584     }
35585   }
35586
35587   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35588   return jresult;
35589 }
35590
35591
35592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35593   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35594   bool arg2 ;
35595
35596   arg1 = (Dali::Actor *)jarg1;
35597   arg2 = jarg2 ? true : false;
35598   {
35599     try {
35600       (arg1)->SetVisible(arg2);
35601     } catch (std::out_of_range& e) {
35602       {
35603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35604       };
35605     } catch (std::exception& e) {
35606       {
35607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35608       };
35609     } catch (Dali::DaliException e) {
35610       {
35611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35612       };
35613     } catch (...) {
35614       {
35615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35616       };
35617     }
35618   }
35619
35620 }
35621
35622
35623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35624   unsigned int jresult ;
35625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35626   bool result;
35627
35628   arg1 = (Dali::Actor *)jarg1;
35629   {
35630     try {
35631       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35632     } catch (std::out_of_range& e) {
35633       {
35634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35635       };
35636     } catch (std::exception& e) {
35637       {
35638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35639       };
35640     } catch (Dali::DaliException e) {
35641       {
35642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35643       };
35644     } catch (...) {
35645       {
35646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35647       };
35648     }
35649   }
35650
35651   jresult = result;
35652   return jresult;
35653 }
35654
35655
35656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35657   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35658   float arg2 ;
35659
35660   arg1 = (Dali::Actor *)jarg1;
35661   arg2 = (float)jarg2;
35662   {
35663     try {
35664       (arg1)->SetOpacity(arg2);
35665     } catch (std::out_of_range& e) {
35666       {
35667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35668       };
35669     } catch (std::exception& e) {
35670       {
35671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35672       };
35673     } catch (Dali::DaliException e) {
35674       {
35675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35676       };
35677     } catch (...) {
35678       {
35679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35680       };
35681     }
35682   }
35683
35684 }
35685
35686
35687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35688   float jresult ;
35689   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35690   float result;
35691
35692   arg1 = (Dali::Actor *)jarg1;
35693   {
35694     try {
35695       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35696     } catch (std::out_of_range& e) {
35697       {
35698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35699       };
35700     } catch (std::exception& e) {
35701       {
35702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35703       };
35704     } catch (Dali::DaliException e) {
35705       {
35706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35707       };
35708     } catch (...) {
35709       {
35710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35711       };
35712     }
35713   }
35714
35715   jresult = result;
35716   return jresult;
35717 }
35718
35719
35720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35721   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35722   Dali::Vector4 *arg2 = 0 ;
35723
35724   arg1 = (Dali::Actor *)jarg1;
35725   arg2 = (Dali::Vector4 *)jarg2;
35726   if (!arg2) {
35727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35728     return ;
35729   }
35730   {
35731     try {
35732       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35733     } catch (std::out_of_range& e) {
35734       {
35735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35736       };
35737     } catch (std::exception& e) {
35738       {
35739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35740       };
35741     } catch (Dali::DaliException e) {
35742       {
35743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35744       };
35745     } catch (...) {
35746       {
35747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35748       };
35749     }
35750   }
35751
35752 }
35753
35754
35755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35756   void * jresult ;
35757   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35758   Dali::Vector4 result;
35759
35760   arg1 = (Dali::Actor *)jarg1;
35761   {
35762     try {
35763       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35764     } catch (std::out_of_range& e) {
35765       {
35766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35767       };
35768     } catch (std::exception& e) {
35769       {
35770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35771       };
35772     } catch (Dali::DaliException e) {
35773       {
35774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35775       };
35776     } catch (...) {
35777       {
35778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35779       };
35780     }
35781   }
35782
35783   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35784   return jresult;
35785 }
35786
35787
35788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35789   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35790   Dali::ColorMode arg2 ;
35791
35792   arg1 = (Dali::Actor *)jarg1;
35793   arg2 = (Dali::ColorMode)jarg2;
35794   {
35795     try {
35796       (arg1)->SetColorMode(arg2);
35797     } catch (std::out_of_range& e) {
35798       {
35799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35800       };
35801     } catch (std::exception& e) {
35802       {
35803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35804       };
35805     } catch (Dali::DaliException e) {
35806       {
35807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35808       };
35809     } catch (...) {
35810       {
35811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35812       };
35813     }
35814   }
35815
35816 }
35817
35818
35819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35820   int jresult ;
35821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35822   Dali::ColorMode result;
35823
35824   arg1 = (Dali::Actor *)jarg1;
35825   {
35826     try {
35827       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35828     } catch (std::out_of_range& e) {
35829       {
35830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35831       };
35832     } catch (std::exception& e) {
35833       {
35834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35835       };
35836     } catch (Dali::DaliException e) {
35837       {
35838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35839       };
35840     } catch (...) {
35841       {
35842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35843       };
35844     }
35845   }
35846
35847   jresult = (int)result;
35848   return jresult;
35849 }
35850
35851
35852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35853   void * jresult ;
35854   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35855   Dali::Vector4 result;
35856
35857   arg1 = (Dali::Actor *)jarg1;
35858   {
35859     try {
35860       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35861     } catch (std::out_of_range& e) {
35862       {
35863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35864       };
35865     } catch (std::exception& e) {
35866       {
35867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35868       };
35869     } catch (Dali::DaliException e) {
35870       {
35871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35872       };
35873     } catch (...) {
35874       {
35875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35876       };
35877     }
35878   }
35879
35880   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35881   return jresult;
35882 }
35883
35884
35885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35887   Dali::DrawMode::Type arg2 ;
35888
35889   arg1 = (Dali::Actor *)jarg1;
35890   arg2 = (Dali::DrawMode::Type)jarg2;
35891   {
35892     try {
35893       (arg1)->SetDrawMode(arg2);
35894     } catch (std::out_of_range& e) {
35895       {
35896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35897       };
35898     } catch (std::exception& e) {
35899       {
35900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35901       };
35902     } catch (Dali::DaliException e) {
35903       {
35904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35905       };
35906     } catch (...) {
35907       {
35908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35909       };
35910     }
35911   }
35912
35913 }
35914
35915
35916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35917   int jresult ;
35918   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35919   Dali::DrawMode::Type result;
35920
35921   arg1 = (Dali::Actor *)jarg1;
35922   {
35923     try {
35924       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35925     } catch (std::out_of_range& e) {
35926       {
35927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35928       };
35929     } catch (std::exception& e) {
35930       {
35931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35932       };
35933     } catch (Dali::DaliException e) {
35934       {
35935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35936       };
35937     } catch (...) {
35938       {
35939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35940       };
35941     }
35942   }
35943
35944   jresult = (int)result;
35945   return jresult;
35946 }
35947
35948
35949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35951   bool arg2 ;
35952
35953   arg1 = (Dali::Actor *)jarg1;
35954   arg2 = jarg2 ? true : false;
35955   {
35956     try {
35957       (arg1)->SetSensitive(arg2);
35958     } catch (std::out_of_range& e) {
35959       {
35960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35961       };
35962     } catch (std::exception& e) {
35963       {
35964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35965       };
35966     } catch (Dali::DaliException e) {
35967       {
35968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35969       };
35970     } catch (...) {
35971       {
35972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35973       };
35974     }
35975   }
35976
35977 }
35978
35979
35980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35981   unsigned int jresult ;
35982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35983   bool result;
35984
35985   arg1 = (Dali::Actor *)jarg1;
35986   {
35987     try {
35988       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35989     } catch (std::out_of_range& e) {
35990       {
35991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35992       };
35993     } catch (std::exception& e) {
35994       {
35995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35996       };
35997     } catch (Dali::DaliException e) {
35998       {
35999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36000       };
36001     } catch (...) {
36002       {
36003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36004       };
36005     }
36006   }
36007
36008   jresult = result;
36009   return jresult;
36010 }
36011
36012
36013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36014   unsigned int jresult ;
36015   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36016   float *arg2 = 0 ;
36017   float *arg3 = 0 ;
36018   float arg4 ;
36019   float arg5 ;
36020   bool result;
36021
36022   arg1 = (Dali::Actor *)jarg1;
36023   arg2 = (float *)jarg2;
36024   arg3 = (float *)jarg3;
36025   arg4 = (float)jarg4;
36026   arg5 = (float)jarg5;
36027   {
36028     try {
36029       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36030     } catch (std::out_of_range& e) {
36031       {
36032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36033       };
36034     } catch (std::exception& e) {
36035       {
36036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36037       };
36038     } catch (Dali::DaliException e) {
36039       {
36040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36041       };
36042     } catch (...) {
36043       {
36044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36045       };
36046     }
36047   }
36048
36049   jresult = result;
36050   return jresult;
36051 }
36052
36053
36054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36055   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36056   bool arg2 ;
36057
36058   arg1 = (Dali::Actor *)jarg1;
36059   arg2 = jarg2 ? true : false;
36060   {
36061     try {
36062       (arg1)->SetLeaveRequired(arg2);
36063     } catch (std::out_of_range& e) {
36064       {
36065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36066       };
36067     } catch (std::exception& e) {
36068       {
36069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36070       };
36071     } catch (Dali::DaliException e) {
36072       {
36073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36074       };
36075     } catch (...) {
36076       {
36077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36078       };
36079     }
36080   }
36081
36082 }
36083
36084
36085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36086   unsigned int jresult ;
36087   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36088   bool result;
36089
36090   arg1 = (Dali::Actor *)jarg1;
36091   {
36092     try {
36093       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36094     } catch (std::out_of_range& e) {
36095       {
36096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36097       };
36098     } catch (std::exception& e) {
36099       {
36100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36101       };
36102     } catch (Dali::DaliException e) {
36103       {
36104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36105       };
36106     } catch (...) {
36107       {
36108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36109       };
36110     }
36111   }
36112
36113   jresult = result;
36114   return jresult;
36115 }
36116
36117
36118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36119   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36120   bool arg2 ;
36121
36122   arg1 = (Dali::Actor *)jarg1;
36123   arg2 = jarg2 ? true : false;
36124   {
36125     try {
36126       (arg1)->SetKeyboardFocusable(arg2);
36127     } catch (std::out_of_range& e) {
36128       {
36129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36130       };
36131     } catch (std::exception& e) {
36132       {
36133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36134       };
36135     } catch (Dali::DaliException e) {
36136       {
36137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36138       };
36139     } catch (...) {
36140       {
36141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36142       };
36143     }
36144   }
36145
36146 }
36147
36148
36149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36150   unsigned int jresult ;
36151   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36152   bool result;
36153
36154   arg1 = (Dali::Actor *)jarg1;
36155   {
36156     try {
36157       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36158     } catch (std::out_of_range& e) {
36159       {
36160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36161       };
36162     } catch (std::exception& e) {
36163       {
36164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36165       };
36166     } catch (Dali::DaliException e) {
36167       {
36168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36169       };
36170     } catch (...) {
36171       {
36172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36173       };
36174     }
36175   }
36176
36177   jresult = result;
36178   return jresult;
36179 }
36180
36181
36182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36183   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36184   Dali::ResizePolicy::Type arg2 ;
36185   Dali::Dimension::Type arg3 ;
36186
36187   arg1 = (Dali::Actor *)jarg1;
36188   arg2 = (Dali::ResizePolicy::Type)jarg2;
36189   arg3 = (Dali::Dimension::Type)jarg3;
36190   {
36191     try {
36192       (arg1)->SetResizePolicy(arg2,arg3);
36193     } catch (std::out_of_range& e) {
36194       {
36195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36196       };
36197     } catch (std::exception& e) {
36198       {
36199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36200       };
36201     } catch (Dali::DaliException e) {
36202       {
36203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36204       };
36205     } catch (...) {
36206       {
36207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36208       };
36209     }
36210   }
36211
36212 }
36213
36214
36215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36216   int jresult ;
36217   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36218   Dali::Dimension::Type arg2 ;
36219   Dali::ResizePolicy::Type result;
36220
36221   arg1 = (Dali::Actor *)jarg1;
36222   arg2 = (Dali::Dimension::Type)jarg2;
36223   {
36224     try {
36225       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36226     } catch (std::out_of_range& e) {
36227       {
36228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36229       };
36230     } catch (std::exception& e) {
36231       {
36232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36233       };
36234     } catch (Dali::DaliException e) {
36235       {
36236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36237       };
36238     } catch (...) {
36239       {
36240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36241       };
36242     }
36243   }
36244
36245   jresult = (int)result;
36246   return jresult;
36247 }
36248
36249
36250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36251   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36252   Dali::SizeScalePolicy::Type arg2 ;
36253
36254   arg1 = (Dali::Actor *)jarg1;
36255   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36256   {
36257     try {
36258       (arg1)->SetSizeScalePolicy(arg2);
36259     } catch (std::out_of_range& e) {
36260       {
36261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36262       };
36263     } catch (std::exception& e) {
36264       {
36265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36266       };
36267     } catch (Dali::DaliException e) {
36268       {
36269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36270       };
36271     } catch (...) {
36272       {
36273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36274       };
36275     }
36276   }
36277
36278 }
36279
36280
36281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36282   int jresult ;
36283   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36284   Dali::SizeScalePolicy::Type result;
36285
36286   arg1 = (Dali::Actor *)jarg1;
36287   {
36288     try {
36289       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36290     } catch (std::out_of_range& e) {
36291       {
36292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36293       };
36294     } catch (std::exception& e) {
36295       {
36296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36297       };
36298     } catch (Dali::DaliException e) {
36299       {
36300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36301       };
36302     } catch (...) {
36303       {
36304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36305       };
36306     }
36307   }
36308
36309   jresult = (int)result;
36310   return jresult;
36311 }
36312
36313
36314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36315   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36316   Dali::Vector3 *arg2 = 0 ;
36317
36318   arg1 = (Dali::Actor *)jarg1;
36319   arg2 = (Dali::Vector3 *)jarg2;
36320   if (!arg2) {
36321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36322     return ;
36323   }
36324   {
36325     try {
36326       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36327     } catch (std::out_of_range& e) {
36328       {
36329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36330       };
36331     } catch (std::exception& e) {
36332       {
36333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36334       };
36335     } catch (Dali::DaliException e) {
36336       {
36337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36338       };
36339     } catch (...) {
36340       {
36341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36342       };
36343     }
36344   }
36345
36346 }
36347
36348
36349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36350   void * jresult ;
36351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36352   Dali::Vector3 result;
36353
36354   arg1 = (Dali::Actor *)jarg1;
36355   {
36356     try {
36357       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36358     } catch (std::out_of_range& e) {
36359       {
36360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36361       };
36362     } catch (std::exception& e) {
36363       {
36364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36365       };
36366     } catch (Dali::DaliException e) {
36367       {
36368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36369       };
36370     } catch (...) {
36371       {
36372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36373       };
36374     }
36375   }
36376
36377   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36378   return jresult;
36379 }
36380
36381
36382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36383   float jresult ;
36384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36385   float arg2 ;
36386   float result;
36387
36388   arg1 = (Dali::Actor *)jarg1;
36389   arg2 = (float)jarg2;
36390   {
36391     try {
36392       result = (float)(arg1)->GetHeightForWidth(arg2);
36393     } catch (std::out_of_range& e) {
36394       {
36395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36396       };
36397     } catch (std::exception& e) {
36398       {
36399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36400       };
36401     } catch (Dali::DaliException e) {
36402       {
36403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36404       };
36405     } catch (...) {
36406       {
36407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36408       };
36409     }
36410   }
36411
36412   jresult = result;
36413   return jresult;
36414 }
36415
36416
36417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36418   float jresult ;
36419   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36420   float arg2 ;
36421   float result;
36422
36423   arg1 = (Dali::Actor *)jarg1;
36424   arg2 = (float)jarg2;
36425   {
36426     try {
36427       result = (float)(arg1)->GetWidthForHeight(arg2);
36428     } catch (std::out_of_range& e) {
36429       {
36430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36431       };
36432     } catch (std::exception& e) {
36433       {
36434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36435       };
36436     } catch (Dali::DaliException e) {
36437       {
36438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36439       };
36440     } catch (...) {
36441       {
36442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36443       };
36444     }
36445   }
36446
36447   jresult = result;
36448   return jresult;
36449 }
36450
36451
36452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36453   float jresult ;
36454   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36455   Dali::Dimension::Type arg2 ;
36456   float result;
36457
36458   arg1 = (Dali::Actor *)jarg1;
36459   arg2 = (Dali::Dimension::Type)jarg2;
36460   {
36461     try {
36462       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36463     } catch (std::out_of_range& e) {
36464       {
36465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36466       };
36467     } catch (std::exception& e) {
36468       {
36469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36470       };
36471     } catch (Dali::DaliException e) {
36472       {
36473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36474       };
36475     } catch (...) {
36476       {
36477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36478       };
36479     }
36480   }
36481
36482   jresult = result;
36483   return jresult;
36484 }
36485
36486
36487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36489   Dali::Padding *arg2 = 0 ;
36490
36491   arg1 = (Dali::Actor *)jarg1;
36492   arg2 = (Dali::Padding *)jarg2;
36493   if (!arg2) {
36494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36495     return ;
36496   }
36497   {
36498     try {
36499       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36500     } catch (std::out_of_range& e) {
36501       {
36502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36503       };
36504     } catch (std::exception& e) {
36505       {
36506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36507       };
36508     } catch (Dali::DaliException e) {
36509       {
36510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36511       };
36512     } catch (...) {
36513       {
36514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36515       };
36516     }
36517   }
36518
36519 }
36520
36521
36522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36523   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36524   Dali::Padding *arg2 = 0 ;
36525
36526   arg1 = (Dali::Actor *)jarg1;
36527   arg2 = (Dali::Padding *)jarg2;
36528   if (!arg2) {
36529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36530     return ;
36531   }
36532   {
36533     try {
36534       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36535     } catch (std::out_of_range& e) {
36536       {
36537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36538       };
36539     } catch (std::exception& e) {
36540       {
36541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36542       };
36543     } catch (Dali::DaliException e) {
36544       {
36545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36546       };
36547     } catch (...) {
36548       {
36549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36550       };
36551     }
36552   }
36553
36554 }
36555
36556
36557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36558   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36559   Dali::Vector2 *arg2 = 0 ;
36560
36561   arg1 = (Dali::Actor *)jarg1;
36562   arg2 = (Dali::Vector2 *)jarg2;
36563   if (!arg2) {
36564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36565     return ;
36566   }
36567   {
36568     try {
36569       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36570     } catch (std::out_of_range& e) {
36571       {
36572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36573       };
36574     } catch (std::exception& e) {
36575       {
36576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36577       };
36578     } catch (Dali::DaliException e) {
36579       {
36580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36581       };
36582     } catch (...) {
36583       {
36584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36585       };
36586     }
36587   }
36588
36589 }
36590
36591
36592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36593   void * jresult ;
36594   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36595   Dali::Vector2 result;
36596
36597   arg1 = (Dali::Actor *)jarg1;
36598   {
36599     try {
36600       result = (arg1)->GetMinimumSize();
36601     } catch (std::out_of_range& e) {
36602       {
36603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36604       };
36605     } catch (std::exception& e) {
36606       {
36607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36608       };
36609     } catch (Dali::DaliException e) {
36610       {
36611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36612       };
36613     } catch (...) {
36614       {
36615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36616       };
36617     }
36618   }
36619
36620   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36621   return jresult;
36622 }
36623
36624
36625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36627   Dali::Vector2 *arg2 = 0 ;
36628
36629   arg1 = (Dali::Actor *)jarg1;
36630   arg2 = (Dali::Vector2 *)jarg2;
36631   if (!arg2) {
36632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36633     return ;
36634   }
36635   {
36636     try {
36637       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36638     } catch (std::out_of_range& e) {
36639       {
36640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36641       };
36642     } catch (std::exception& e) {
36643       {
36644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36645       };
36646     } catch (Dali::DaliException e) {
36647       {
36648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36649       };
36650     } catch (...) {
36651       {
36652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36653       };
36654     }
36655   }
36656
36657 }
36658
36659
36660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36661   void * jresult ;
36662   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36663   Dali::Vector2 result;
36664
36665   arg1 = (Dali::Actor *)jarg1;
36666   {
36667     try {
36668       result = (arg1)->GetMaximumSize();
36669     } catch (std::out_of_range& e) {
36670       {
36671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36672       };
36673     } catch (std::exception& e) {
36674       {
36675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36676       };
36677     } catch (Dali::DaliException e) {
36678       {
36679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36680       };
36681     } catch (...) {
36682       {
36683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36684       };
36685     }
36686   }
36687
36688   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36689   return jresult;
36690 }
36691
36692
36693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36694   int jresult ;
36695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36696   int result;
36697
36698   arg1 = (Dali::Actor *)jarg1;
36699   {
36700     try {
36701       result = (int)(arg1)->GetHierarchyDepth();
36702     } catch (std::out_of_range& e) {
36703       {
36704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36705       };
36706     } catch (std::exception& e) {
36707       {
36708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36709       };
36710     } catch (Dali::DaliException e) {
36711       {
36712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36713       };
36714     } catch (...) {
36715       {
36716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36717       };
36718     }
36719   }
36720
36721   jresult = result;
36722   return jresult;
36723 }
36724
36725
36726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36727   unsigned int jresult ;
36728   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36729   Dali::Renderer *arg2 = 0 ;
36730   unsigned int result;
36731
36732   arg1 = (Dali::Actor *)jarg1;
36733   arg2 = (Dali::Renderer *)jarg2;
36734   if (!arg2) {
36735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36736     return 0;
36737   }
36738   {
36739     try {
36740       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36741     } catch (std::out_of_range& e) {
36742       {
36743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36744       };
36745     } catch (std::exception& e) {
36746       {
36747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36748       };
36749     } catch (Dali::DaliException e) {
36750       {
36751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36752       };
36753     } catch (...) {
36754       {
36755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36756       };
36757     }
36758   }
36759
36760   jresult = result;
36761   return jresult;
36762 }
36763
36764
36765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36766   unsigned int jresult ;
36767   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36768   unsigned int result;
36769
36770   arg1 = (Dali::Actor *)jarg1;
36771   {
36772     try {
36773       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36774     } catch (std::out_of_range& e) {
36775       {
36776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36777       };
36778     } catch (std::exception& e) {
36779       {
36780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36781       };
36782     } catch (Dali::DaliException e) {
36783       {
36784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36785       };
36786     } catch (...) {
36787       {
36788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36789       };
36790     }
36791   }
36792
36793   jresult = result;
36794   return jresult;
36795 }
36796
36797
36798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36799   void * jresult ;
36800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36801   unsigned int arg2 ;
36802   Dali::Renderer result;
36803
36804   arg1 = (Dali::Actor *)jarg1;
36805   arg2 = (unsigned int)jarg2;
36806   {
36807     try {
36808       result = (arg1)->GetRendererAt(arg2);
36809     } catch (std::out_of_range& e) {
36810       {
36811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36812       };
36813     } catch (std::exception& e) {
36814       {
36815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36816       };
36817     } catch (Dali::DaliException e) {
36818       {
36819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36820       };
36821     } catch (...) {
36822       {
36823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36824       };
36825     }
36826   }
36827
36828   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36829   return jresult;
36830 }
36831
36832
36833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36835   Dali::Renderer *arg2 = 0 ;
36836
36837   arg1 = (Dali::Actor *)jarg1;
36838   arg2 = (Dali::Renderer *)jarg2;
36839   if (!arg2) {
36840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36841     return ;
36842   }
36843   {
36844     try {
36845       (arg1)->RemoveRenderer(*arg2);
36846     } catch (std::out_of_range& e) {
36847       {
36848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36849       };
36850     } catch (std::exception& e) {
36851       {
36852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36853       };
36854     } catch (Dali::DaliException e) {
36855       {
36856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36857       };
36858     } catch (...) {
36859       {
36860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36861       };
36862     }
36863   }
36864
36865 }
36866
36867
36868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36869   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36870   unsigned int arg2 ;
36871
36872   arg1 = (Dali::Actor *)jarg1;
36873   arg2 = (unsigned int)jarg2;
36874   {
36875     try {
36876       (arg1)->RemoveRenderer(arg2);
36877     } catch (std::out_of_range& e) {
36878       {
36879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36880       };
36881     } catch (std::exception& e) {
36882       {
36883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36884       };
36885     } catch (Dali::DaliException e) {
36886       {
36887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36888       };
36889     } catch (...) {
36890       {
36891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36892       };
36893     }
36894   }
36895
36896 }
36897
36898
36899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36900   void * jresult ;
36901   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36902   Dali::Actor::TouchSignalType *result = 0 ;
36903
36904   arg1 = (Dali::Actor *)jarg1;
36905   {
36906     try {
36907       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36908     } catch (std::out_of_range& e) {
36909       {
36910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36911       };
36912     } catch (std::exception& e) {
36913       {
36914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36915       };
36916     } catch (Dali::DaliException e) {
36917       {
36918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36919       };
36920     } catch (...) {
36921       {
36922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36923       };
36924     }
36925   }
36926
36927   jresult = (void *)result;
36928   return jresult;
36929 }
36930
36931
36932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36933   void * jresult ;
36934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36935   Dali::Actor::TouchDataSignalType *result = 0 ;
36936
36937   arg1 = (Dali::Actor *)jarg1;
36938   {
36939     try {
36940       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36941     } catch (std::out_of_range& e) {
36942       {
36943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36944       };
36945     } catch (std::exception& e) {
36946       {
36947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36948       };
36949     } catch (Dali::DaliException e) {
36950       {
36951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36952       };
36953     } catch (...) {
36954       {
36955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36956       };
36957     }
36958   }
36959
36960   jresult = (void *)result;
36961   return jresult;
36962 }
36963
36964
36965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36966   void * jresult ;
36967   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36968   Dali::Actor::HoverSignalType *result = 0 ;
36969
36970   arg1 = (Dali::Actor *)jarg1;
36971   {
36972     try {
36973       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36974     } catch (std::out_of_range& e) {
36975       {
36976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36977       };
36978     } catch (std::exception& e) {
36979       {
36980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36981       };
36982     } catch (Dali::DaliException e) {
36983       {
36984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36985       };
36986     } catch (...) {
36987       {
36988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36989       };
36990     }
36991   }
36992
36993   jresult = (void *)result;
36994   return jresult;
36995 }
36996
36997
36998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36999   void * jresult ;
37000   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37001   Dali::Actor::WheelEventSignalType *result = 0 ;
37002
37003   arg1 = (Dali::Actor *)jarg1;
37004   {
37005     try {
37006       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37007     } catch (std::out_of_range& e) {
37008       {
37009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37010       };
37011     } catch (std::exception& e) {
37012       {
37013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37014       };
37015     } catch (Dali::DaliException e) {
37016       {
37017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37018       };
37019     } catch (...) {
37020       {
37021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37022       };
37023     }
37024   }
37025
37026   jresult = (void *)result;
37027   return jresult;
37028 }
37029
37030
37031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37032   void * jresult ;
37033   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37034   Dali::Actor::OnStageSignalType *result = 0 ;
37035
37036   arg1 = (Dali::Actor *)jarg1;
37037   {
37038     try {
37039       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37040     } catch (std::out_of_range& e) {
37041       {
37042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37043       };
37044     } catch (std::exception& e) {
37045       {
37046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37047       };
37048     } catch (Dali::DaliException e) {
37049       {
37050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37051       };
37052     } catch (...) {
37053       {
37054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37055       };
37056     }
37057   }
37058
37059   jresult = (void *)result;
37060   return jresult;
37061 }
37062
37063
37064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37065   void * jresult ;
37066   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37067   Dali::Actor::OffStageSignalType *result = 0 ;
37068
37069   arg1 = (Dali::Actor *)jarg1;
37070   {
37071     try {
37072       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37073     } catch (std::out_of_range& e) {
37074       {
37075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37076       };
37077     } catch (std::exception& e) {
37078       {
37079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37080       };
37081     } catch (Dali::DaliException e) {
37082       {
37083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37084       };
37085     } catch (...) {
37086       {
37087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37088       };
37089     }
37090   }
37091
37092   jresult = (void *)result;
37093   return jresult;
37094 }
37095
37096
37097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37098   void * jresult ;
37099   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37100   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37101
37102   arg1 = (Dali::Actor *)jarg1;
37103   {
37104     try {
37105       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37106     } catch (std::out_of_range& e) {
37107       {
37108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37109       };
37110     } catch (std::exception& e) {
37111       {
37112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37113       };
37114     } catch (Dali::DaliException e) {
37115       {
37116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37117       };
37118     } catch (...) {
37119       {
37120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37121       };
37122     }
37123   }
37124
37125   jresult = (void *)result;
37126   return jresult;
37127 }
37128
37129
37130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37131   Dali::Actor *arg1 = 0 ;
37132
37133   arg1 = (Dali::Actor *)jarg1;
37134   if (!arg1) {
37135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37136     return ;
37137   }
37138   {
37139     try {
37140       Dali::UnparentAndReset(*arg1);
37141     } catch (std::out_of_range& e) {
37142       {
37143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37144       };
37145     } catch (std::exception& e) {
37146       {
37147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37148       };
37149     } catch (Dali::DaliException e) {
37150       {
37151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37152       };
37153     } catch (...) {
37154       {
37155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37156       };
37157     }
37158   }
37159
37160 }
37161
37162
37163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37164   int jresult ;
37165   int result;
37166
37167   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37168   jresult = (int)result;
37169   return jresult;
37170 }
37171
37172
37173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37174   int jresult ;
37175   int result;
37176
37177   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37178   jresult = (int)result;
37179   return jresult;
37180 }
37181
37182
37183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37184   int jresult ;
37185   int result;
37186
37187   result = (int)Dali::Layer::Property::BEHAVIOR;
37188   jresult = (int)result;
37189   return jresult;
37190 }
37191
37192
37193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37194   void * jresult ;
37195   Dali::Layer::Property *result = 0 ;
37196
37197   {
37198     try {
37199       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37200     } catch (std::out_of_range& e) {
37201       {
37202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37203       };
37204     } catch (std::exception& e) {
37205       {
37206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37207       };
37208     } catch (Dali::DaliException e) {
37209       {
37210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37211       };
37212     } catch (...) {
37213       {
37214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37215       };
37216     }
37217   }
37218
37219   jresult = (void *)result;
37220   return jresult;
37221 }
37222
37223
37224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37225   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37226
37227   arg1 = (Dali::Layer::Property *)jarg1;
37228   {
37229     try {
37230       delete arg1;
37231     } catch (std::out_of_range& e) {
37232       {
37233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37234       };
37235     } catch (std::exception& e) {
37236       {
37237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37238       };
37239     } catch (Dali::DaliException e) {
37240       {
37241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37242       };
37243     } catch (...) {
37244       {
37245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37246       };
37247     }
37248   }
37249
37250 }
37251
37252
37253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37254   void * jresult ;
37255   Dali::Layer *result = 0 ;
37256
37257   {
37258     try {
37259       result = (Dali::Layer *)new Dali::Layer();
37260     } catch (std::out_of_range& e) {
37261       {
37262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37263       };
37264     } catch (std::exception& e) {
37265       {
37266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37267       };
37268     } catch (Dali::DaliException e) {
37269       {
37270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37271       };
37272     } catch (...) {
37273       {
37274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37275       };
37276     }
37277   }
37278
37279   jresult = (void *)result;
37280   return jresult;
37281 }
37282
37283
37284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37285   void * jresult ;
37286   Dali::Layer result;
37287
37288   {
37289     try {
37290       result = Dali::Layer::New();
37291     } catch (std::out_of_range& e) {
37292       {
37293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37294       };
37295     } catch (std::exception& e) {
37296       {
37297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37298       };
37299     } catch (Dali::DaliException e) {
37300       {
37301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37302       };
37303     } catch (...) {
37304       {
37305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37306       };
37307     }
37308   }
37309
37310   jresult = new Dali::Layer((const Dali::Layer &)result);
37311   return jresult;
37312 }
37313
37314
37315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37316   void * jresult ;
37317   Dali::BaseHandle arg1 ;
37318   Dali::BaseHandle *argp1 ;
37319   Dali::Layer result;
37320
37321   argp1 = (Dali::BaseHandle *)jarg1;
37322   if (!argp1) {
37323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37324     return 0;
37325   }
37326   arg1 = *argp1;
37327   {
37328     try {
37329       result = Dali::Layer::DownCast(arg1);
37330     } catch (std::out_of_range& e) {
37331       {
37332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37333       };
37334     } catch (std::exception& e) {
37335       {
37336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37337       };
37338     } catch (Dali::DaliException e) {
37339       {
37340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37341       };
37342     } catch (...) {
37343       {
37344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37345       };
37346     }
37347   }
37348
37349   jresult = new Dali::Layer((const Dali::Layer &)result);
37350   return jresult;
37351 }
37352
37353
37354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37355   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37356
37357   arg1 = (Dali::Layer *)jarg1;
37358   {
37359     try {
37360       delete arg1;
37361     } catch (std::out_of_range& e) {
37362       {
37363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37364       };
37365     } catch (std::exception& e) {
37366       {
37367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37368       };
37369     } catch (Dali::DaliException e) {
37370       {
37371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37372       };
37373     } catch (...) {
37374       {
37375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37376       };
37377     }
37378   }
37379
37380 }
37381
37382
37383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37384   void * jresult ;
37385   Dali::Layer *arg1 = 0 ;
37386   Dali::Layer *result = 0 ;
37387
37388   arg1 = (Dali::Layer *)jarg1;
37389   if (!arg1) {
37390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37391     return 0;
37392   }
37393   {
37394     try {
37395       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37396     } catch (std::out_of_range& e) {
37397       {
37398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37399       };
37400     } catch (std::exception& e) {
37401       {
37402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37403       };
37404     } catch (Dali::DaliException e) {
37405       {
37406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37407       };
37408     } catch (...) {
37409       {
37410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37411       };
37412     }
37413   }
37414
37415   jresult = (void *)result;
37416   return jresult;
37417 }
37418
37419
37420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37421   void * jresult ;
37422   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37423   Dali::Layer *arg2 = 0 ;
37424   Dali::Layer *result = 0 ;
37425
37426   arg1 = (Dali::Layer *)jarg1;
37427   arg2 = (Dali::Layer *)jarg2;
37428   if (!arg2) {
37429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37430     return 0;
37431   }
37432   {
37433     try {
37434       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37435     } catch (std::out_of_range& e) {
37436       {
37437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37438       };
37439     } catch (std::exception& e) {
37440       {
37441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37442       };
37443     } catch (Dali::DaliException e) {
37444       {
37445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37446       };
37447     } catch (...) {
37448       {
37449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37450       };
37451     }
37452   }
37453
37454   jresult = (void *)result;
37455   return jresult;
37456 }
37457
37458
37459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37460   unsigned int jresult ;
37461   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37462   unsigned int result;
37463
37464   arg1 = (Dali::Layer *)jarg1;
37465   {
37466     try {
37467       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37468     } catch (std::out_of_range& e) {
37469       {
37470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37471       };
37472     } catch (std::exception& e) {
37473       {
37474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37475       };
37476     } catch (Dali::DaliException e) {
37477       {
37478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37479       };
37480     } catch (...) {
37481       {
37482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37483       };
37484     }
37485   }
37486
37487   jresult = result;
37488   return jresult;
37489 }
37490
37491
37492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37493   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37494
37495   arg1 = (Dali::Layer *)jarg1;
37496   {
37497     try {
37498       (arg1)->Raise();
37499     } catch (std::out_of_range& e) {
37500       {
37501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37502       };
37503     } catch (std::exception& e) {
37504       {
37505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37506       };
37507     } catch (Dali::DaliException e) {
37508       {
37509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37510       };
37511     } catch (...) {
37512       {
37513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37514       };
37515     }
37516   }
37517
37518 }
37519
37520
37521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37522   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37523
37524   arg1 = (Dali::Layer *)jarg1;
37525   {
37526     try {
37527       (arg1)->Lower();
37528     } catch (std::out_of_range& e) {
37529       {
37530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37531       };
37532     } catch (std::exception& e) {
37533       {
37534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37535       };
37536     } catch (Dali::DaliException e) {
37537       {
37538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37539       };
37540     } catch (...) {
37541       {
37542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37543       };
37544     }
37545   }
37546
37547 }
37548
37549
37550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37551   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37552   Dali::Layer arg2 ;
37553   Dali::Layer *argp2 ;
37554
37555   arg1 = (Dali::Layer *)jarg1;
37556   argp2 = (Dali::Layer *)jarg2;
37557   if (!argp2) {
37558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37559     return ;
37560   }
37561   arg2 = *argp2;
37562   {
37563     try {
37564       (arg1)->RaiseAbove(arg2);
37565     } catch (std::out_of_range& e) {
37566       {
37567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37568       };
37569     } catch (std::exception& e) {
37570       {
37571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37572       };
37573     } catch (Dali::DaliException e) {
37574       {
37575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37576       };
37577     } catch (...) {
37578       {
37579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37580       };
37581     }
37582   }
37583
37584 }
37585
37586
37587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37588   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37589   Dali::Layer arg2 ;
37590   Dali::Layer *argp2 ;
37591
37592   arg1 = (Dali::Layer *)jarg1;
37593   argp2 = (Dali::Layer *)jarg2;
37594   if (!argp2) {
37595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37596     return ;
37597   }
37598   arg2 = *argp2;
37599   {
37600     try {
37601       (arg1)->LowerBelow(arg2);
37602     } catch (std::out_of_range& e) {
37603       {
37604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37605       };
37606     } catch (std::exception& e) {
37607       {
37608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37609       };
37610     } catch (Dali::DaliException e) {
37611       {
37612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37613       };
37614     } catch (...) {
37615       {
37616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37617       };
37618     }
37619   }
37620
37621 }
37622
37623
37624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37625   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37626
37627   arg1 = (Dali::Layer *)jarg1;
37628   {
37629     try {
37630       (arg1)->RaiseToTop();
37631     } catch (std::out_of_range& e) {
37632       {
37633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37634       };
37635     } catch (std::exception& e) {
37636       {
37637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37638       };
37639     } catch (Dali::DaliException e) {
37640       {
37641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37642       };
37643     } catch (...) {
37644       {
37645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37646       };
37647     }
37648   }
37649
37650 }
37651
37652
37653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37654   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37655
37656   arg1 = (Dali::Layer *)jarg1;
37657   {
37658     try {
37659       (arg1)->LowerToBottom();
37660     } catch (std::out_of_range& e) {
37661       {
37662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37663       };
37664     } catch (std::exception& e) {
37665       {
37666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37667       };
37668     } catch (Dali::DaliException e) {
37669       {
37670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37671       };
37672     } catch (...) {
37673       {
37674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37675       };
37676     }
37677   }
37678
37679 }
37680
37681
37682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37683   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37684   Dali::Layer arg2 ;
37685   Dali::Layer *argp2 ;
37686
37687   arg1 = (Dali::Layer *)jarg1;
37688   argp2 = (Dali::Layer *)jarg2;
37689   if (!argp2) {
37690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37691     return ;
37692   }
37693   arg2 = *argp2;
37694   {
37695     try {
37696       (arg1)->MoveAbove(arg2);
37697     } catch (std::out_of_range& e) {
37698       {
37699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37700       };
37701     } catch (std::exception& e) {
37702       {
37703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37704       };
37705     } catch (Dali::DaliException e) {
37706       {
37707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37708       };
37709     } catch (...) {
37710       {
37711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37712       };
37713     }
37714   }
37715
37716 }
37717
37718
37719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37720   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37721   Dali::Layer arg2 ;
37722   Dali::Layer *argp2 ;
37723
37724   arg1 = (Dali::Layer *)jarg1;
37725   argp2 = (Dali::Layer *)jarg2;
37726   if (!argp2) {
37727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37728     return ;
37729   }
37730   arg2 = *argp2;
37731   {
37732     try {
37733       (arg1)->MoveBelow(arg2);
37734     } catch (std::out_of_range& e) {
37735       {
37736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37737       };
37738     } catch (std::exception& e) {
37739       {
37740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37741       };
37742     } catch (Dali::DaliException e) {
37743       {
37744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37745       };
37746     } catch (...) {
37747       {
37748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37749       };
37750     }
37751   }
37752
37753 }
37754
37755
37756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37757   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37758   Dali::Layer::Behavior arg2 ;
37759
37760   arg1 = (Dali::Layer *)jarg1;
37761   arg2 = (Dali::Layer::Behavior)jarg2;
37762   {
37763     try {
37764       (arg1)->SetBehavior(arg2);
37765     } catch (std::out_of_range& e) {
37766       {
37767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37768       };
37769     } catch (std::exception& e) {
37770       {
37771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37772       };
37773     } catch (Dali::DaliException e) {
37774       {
37775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37776       };
37777     } catch (...) {
37778       {
37779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37780       };
37781     }
37782   }
37783
37784 }
37785
37786
37787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37788   int jresult ;
37789   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37790   Dali::Layer::Behavior result;
37791
37792   arg1 = (Dali::Layer *)jarg1;
37793   {
37794     try {
37795       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37796     } catch (std::out_of_range& e) {
37797       {
37798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37799       };
37800     } catch (std::exception& e) {
37801       {
37802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37803       };
37804     } catch (Dali::DaliException e) {
37805       {
37806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37807       };
37808     } catch (...) {
37809       {
37810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37811       };
37812     }
37813   }
37814
37815   jresult = (int)result;
37816   return jresult;
37817 }
37818
37819
37820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37821   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37822   bool arg2 ;
37823
37824   arg1 = (Dali::Layer *)jarg1;
37825   arg2 = jarg2 ? true : false;
37826   {
37827     try {
37828       (arg1)->SetClipping(arg2);
37829     } catch (std::out_of_range& e) {
37830       {
37831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37832       };
37833     } catch (std::exception& e) {
37834       {
37835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37836       };
37837     } catch (Dali::DaliException e) {
37838       {
37839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37840       };
37841     } catch (...) {
37842       {
37843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37844       };
37845     }
37846   }
37847
37848 }
37849
37850
37851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37852   unsigned int jresult ;
37853   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37854   bool result;
37855
37856   arg1 = (Dali::Layer *)jarg1;
37857   {
37858     try {
37859       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37860     } catch (std::out_of_range& e) {
37861       {
37862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37863       };
37864     } catch (std::exception& e) {
37865       {
37866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37867       };
37868     } catch (Dali::DaliException e) {
37869       {
37870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37871       };
37872     } catch (...) {
37873       {
37874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37875       };
37876     }
37877   }
37878
37879   jresult = result;
37880   return jresult;
37881 }
37882
37883
37884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37885   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37886   int arg2 ;
37887   int arg3 ;
37888   int arg4 ;
37889   int arg5 ;
37890
37891   arg1 = (Dali::Layer *)jarg1;
37892   arg2 = (int)jarg2;
37893   arg3 = (int)jarg3;
37894   arg4 = (int)jarg4;
37895   arg5 = (int)jarg5;
37896   {
37897     try {
37898       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37899     } catch (std::out_of_range& e) {
37900       {
37901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37902       };
37903     } catch (std::exception& e) {
37904       {
37905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37906       };
37907     } catch (Dali::DaliException e) {
37908       {
37909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37910       };
37911     } catch (...) {
37912       {
37913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37914       };
37915     }
37916   }
37917
37918 }
37919
37920
37921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37922   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37923   Dali::ClippingBox arg2 ;
37924   Dali::ClippingBox *argp2 ;
37925
37926   arg1 = (Dali::Layer *)jarg1;
37927   argp2 = (Dali::ClippingBox *)jarg2;
37928   if (!argp2) {
37929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37930     return ;
37931   }
37932   arg2 = *argp2;
37933   {
37934     try {
37935       (arg1)->SetClippingBox(arg2);
37936     } catch (std::out_of_range& e) {
37937       {
37938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37939       };
37940     } catch (std::exception& e) {
37941       {
37942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37943       };
37944     } catch (Dali::DaliException e) {
37945       {
37946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37947       };
37948     } catch (...) {
37949       {
37950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37951       };
37952     }
37953   }
37954
37955 }
37956
37957
37958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37959   void * jresult ;
37960   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37961   Dali::ClippingBox result;
37962
37963   arg1 = (Dali::Layer *)jarg1;
37964   {
37965     try {
37966       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37967     } catch (std::out_of_range& e) {
37968       {
37969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37970       };
37971     } catch (std::exception& e) {
37972       {
37973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37974       };
37975     } catch (Dali::DaliException e) {
37976       {
37977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37978       };
37979     } catch (...) {
37980       {
37981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37982       };
37983     }
37984   }
37985
37986   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37987   return jresult;
37988 }
37989
37990
37991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37992   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37993   bool arg2 ;
37994
37995   arg1 = (Dali::Layer *)jarg1;
37996   arg2 = jarg2 ? true : false;
37997   {
37998     try {
37999       (arg1)->SetDepthTestDisabled(arg2);
38000     } catch (std::out_of_range& e) {
38001       {
38002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38003       };
38004     } catch (std::exception& e) {
38005       {
38006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38007       };
38008     } catch (Dali::DaliException e) {
38009       {
38010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38011       };
38012     } catch (...) {
38013       {
38014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38015       };
38016     }
38017   }
38018
38019 }
38020
38021
38022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38023   unsigned int jresult ;
38024   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38025   bool result;
38026
38027   arg1 = (Dali::Layer *)jarg1;
38028   {
38029     try {
38030       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38031     } catch (std::out_of_range& e) {
38032       {
38033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38034       };
38035     } catch (std::exception& e) {
38036       {
38037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38038       };
38039     } catch (Dali::DaliException e) {
38040       {
38041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38042       };
38043     } catch (...) {
38044       {
38045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38046       };
38047     }
38048   }
38049
38050   jresult = result;
38051   return jresult;
38052 }
38053
38054
38055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38056   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38057   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38058
38059   arg1 = (Dali::Layer *)jarg1;
38060   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38061   {
38062     try {
38063       (arg1)->SetSortFunction(arg2);
38064     } catch (std::out_of_range& e) {
38065       {
38066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38067       };
38068     } catch (std::exception& e) {
38069       {
38070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38071       };
38072     } catch (Dali::DaliException e) {
38073       {
38074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38075       };
38076     } catch (...) {
38077       {
38078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38079       };
38080     }
38081   }
38082
38083 }
38084
38085
38086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38087   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38088   bool arg2 ;
38089
38090   arg1 = (Dali::Layer *)jarg1;
38091   arg2 = jarg2 ? true : false;
38092   {
38093     try {
38094       (arg1)->SetTouchConsumed(arg2);
38095     } catch (std::out_of_range& e) {
38096       {
38097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38098       };
38099     } catch (std::exception& e) {
38100       {
38101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38102       };
38103     } catch (Dali::DaliException e) {
38104       {
38105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38106       };
38107     } catch (...) {
38108       {
38109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38110       };
38111     }
38112   }
38113
38114 }
38115
38116
38117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38118   unsigned int jresult ;
38119   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38120   bool result;
38121
38122   arg1 = (Dali::Layer *)jarg1;
38123   {
38124     try {
38125       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38126     } catch (std::out_of_range& e) {
38127       {
38128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38129       };
38130     } catch (std::exception& e) {
38131       {
38132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38133       };
38134     } catch (Dali::DaliException e) {
38135       {
38136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38137       };
38138     } catch (...) {
38139       {
38140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38141       };
38142     }
38143   }
38144
38145   jresult = result;
38146   return jresult;
38147 }
38148
38149
38150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38151   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38152   bool arg2 ;
38153
38154   arg1 = (Dali::Layer *)jarg1;
38155   arg2 = jarg2 ? true : false;
38156   {
38157     try {
38158       (arg1)->SetHoverConsumed(arg2);
38159     } catch (std::out_of_range& e) {
38160       {
38161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38162       };
38163     } catch (std::exception& e) {
38164       {
38165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38166       };
38167     } catch (Dali::DaliException e) {
38168       {
38169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38170       };
38171     } catch (...) {
38172       {
38173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38174       };
38175     }
38176   }
38177
38178 }
38179
38180
38181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38182   unsigned int jresult ;
38183   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38184   bool result;
38185
38186   arg1 = (Dali::Layer *)jarg1;
38187   {
38188     try {
38189       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38190     } catch (std::out_of_range& e) {
38191       {
38192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38193       };
38194     } catch (std::exception& e) {
38195       {
38196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38197       };
38198     } catch (Dali::DaliException e) {
38199       {
38200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38201       };
38202     } catch (...) {
38203       {
38204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38205       };
38206     }
38207   }
38208
38209   jresult = result;
38210   return jresult;
38211 }
38212
38213
38214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38215   void * jresult ;
38216   Dali::Vector4 *result = 0 ;
38217
38218   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38219   jresult = (void *)result;
38220   return jresult;
38221 }
38222
38223
38224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38225   void * jresult ;
38226   Dali::Vector4 *result = 0 ;
38227
38228   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38229   jresult = (void *)result;
38230   return jresult;
38231 }
38232
38233
38234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38235   void * jresult ;
38236   Dali::Stage *result = 0 ;
38237
38238   {
38239     try {
38240       result = (Dali::Stage *)new Dali::Stage();
38241     } catch (std::out_of_range& e) {
38242       {
38243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38244       };
38245     } catch (std::exception& e) {
38246       {
38247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38248       };
38249     } catch (Dali::DaliException e) {
38250       {
38251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38252       };
38253     } catch (...) {
38254       {
38255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38256       };
38257     }
38258   }
38259
38260   jresult = (void *)result;
38261   return jresult;
38262 }
38263
38264
38265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38266   void * jresult ;
38267   Dali::Stage result;
38268
38269   {
38270     try {
38271       result = Dali::Stage::GetCurrent();
38272     } catch (std::out_of_range& e) {
38273       {
38274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38275       };
38276     } catch (std::exception& e) {
38277       {
38278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38279       };
38280     } catch (Dali::DaliException e) {
38281       {
38282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38283       };
38284     } catch (...) {
38285       {
38286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38287       };
38288     }
38289   }
38290
38291   jresult = new Dali::Stage((const Dali::Stage &)result);
38292   return jresult;
38293 }
38294
38295
38296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38297   unsigned int jresult ;
38298   bool result;
38299
38300   {
38301     try {
38302       result = (bool)Dali::Stage::IsInstalled();
38303     } catch (std::out_of_range& e) {
38304       {
38305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38306       };
38307     } catch (std::exception& e) {
38308       {
38309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38310       };
38311     } catch (Dali::DaliException e) {
38312       {
38313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38314       };
38315     } catch (...) {
38316       {
38317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38318       };
38319     }
38320   }
38321
38322   jresult = result;
38323   return jresult;
38324 }
38325
38326
38327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38328   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38329
38330   arg1 = (Dali::Stage *)jarg1;
38331   {
38332     try {
38333       delete arg1;
38334     } catch (std::out_of_range& e) {
38335       {
38336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38337       };
38338     } catch (std::exception& e) {
38339       {
38340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38341       };
38342     } catch (Dali::DaliException e) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38345       };
38346     } catch (...) {
38347       {
38348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38349       };
38350     }
38351   }
38352
38353 }
38354
38355
38356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38357   void * jresult ;
38358   Dali::Stage *arg1 = 0 ;
38359   Dali::Stage *result = 0 ;
38360
38361   arg1 = (Dali::Stage *)jarg1;
38362   if (!arg1) {
38363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38364     return 0;
38365   }
38366   {
38367     try {
38368       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38369     } catch (std::out_of_range& e) {
38370       {
38371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38372       };
38373     } catch (std::exception& e) {
38374       {
38375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38376       };
38377     } catch (Dali::DaliException e) {
38378       {
38379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38380       };
38381     } catch (...) {
38382       {
38383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38384       };
38385     }
38386   }
38387
38388   jresult = (void *)result;
38389   return jresult;
38390 }
38391
38392
38393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38394   void * jresult ;
38395   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38396   Dali::Stage *arg2 = 0 ;
38397   Dali::Stage *result = 0 ;
38398
38399   arg1 = (Dali::Stage *)jarg1;
38400   arg2 = (Dali::Stage *)jarg2;
38401   if (!arg2) {
38402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38403     return 0;
38404   }
38405   {
38406     try {
38407       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38408     } catch (std::out_of_range& e) {
38409       {
38410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38411       };
38412     } catch (std::exception& e) {
38413       {
38414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38415       };
38416     } catch (Dali::DaliException e) {
38417       {
38418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38419       };
38420     } catch (...) {
38421       {
38422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38423       };
38424     }
38425   }
38426
38427   jresult = (void *)result;
38428   return jresult;
38429 }
38430
38431
38432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38433   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38434   Dali::Actor *arg2 = 0 ;
38435
38436   arg1 = (Dali::Stage *)jarg1;
38437   arg2 = (Dali::Actor *)jarg2;
38438   if (!arg2) {
38439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38440     return ;
38441   }
38442   {
38443     try {
38444       (arg1)->Add(*arg2);
38445     } catch (std::out_of_range& e) {
38446       {
38447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38448       };
38449     } catch (std::exception& e) {
38450       {
38451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38452       };
38453     } catch (Dali::DaliException e) {
38454       {
38455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38456       };
38457     } catch (...) {
38458       {
38459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38460       };
38461     }
38462   }
38463
38464 }
38465
38466
38467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38468   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38469   Dali::Actor *arg2 = 0 ;
38470
38471   arg1 = (Dali::Stage *)jarg1;
38472   arg2 = (Dali::Actor *)jarg2;
38473   if (!arg2) {
38474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38475     return ;
38476   }
38477   {
38478     try {
38479       (arg1)->Remove(*arg2);
38480     } catch (std::out_of_range& e) {
38481       {
38482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38483       };
38484     } catch (std::exception& e) {
38485       {
38486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38487       };
38488     } catch (Dali::DaliException e) {
38489       {
38490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38491       };
38492     } catch (...) {
38493       {
38494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38495       };
38496     }
38497   }
38498
38499 }
38500
38501
38502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38503   void * jresult ;
38504   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38505   Dali::Vector2 result;
38506
38507   arg1 = (Dali::Stage *)jarg1;
38508   {
38509     try {
38510       result = ((Dali::Stage const *)arg1)->GetSize();
38511     } catch (std::out_of_range& e) {
38512       {
38513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38514       };
38515     } catch (std::exception& e) {
38516       {
38517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38518       };
38519     } catch (Dali::DaliException e) {
38520       {
38521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38522       };
38523     } catch (...) {
38524       {
38525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38526       };
38527     }
38528   }
38529
38530   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38531   return jresult;
38532 }
38533
38534
38535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38536   void * jresult ;
38537   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38538   Dali::RenderTaskList result;
38539
38540   arg1 = (Dali::Stage *)jarg1;
38541   {
38542     try {
38543       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38544     } catch (std::out_of_range& e) {
38545       {
38546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38547       };
38548     } catch (std::exception& e) {
38549       {
38550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38551       };
38552     } catch (Dali::DaliException e) {
38553       {
38554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38555       };
38556     } catch (...) {
38557       {
38558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38559       };
38560     }
38561   }
38562
38563   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38564   return jresult;
38565 }
38566
38567
38568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38569   unsigned int jresult ;
38570   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38571   unsigned int result;
38572
38573   arg1 = (Dali::Stage *)jarg1;
38574   {
38575     try {
38576       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38577     } catch (std::out_of_range& e) {
38578       {
38579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38580       };
38581     } catch (std::exception& e) {
38582       {
38583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38584       };
38585     } catch (Dali::DaliException e) {
38586       {
38587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38588       };
38589     } catch (...) {
38590       {
38591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38592       };
38593     }
38594   }
38595
38596   jresult = result;
38597   return jresult;
38598 }
38599
38600
38601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38602   void * jresult ;
38603   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38604   unsigned int arg2 ;
38605   Dali::Layer result;
38606
38607   arg1 = (Dali::Stage *)jarg1;
38608   arg2 = (unsigned int)jarg2;
38609   {
38610     try {
38611       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38612     } catch (std::out_of_range& e) {
38613       {
38614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38615       };
38616     } catch (std::exception& e) {
38617       {
38618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38619       };
38620     } catch (Dali::DaliException e) {
38621       {
38622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38623       };
38624     } catch (...) {
38625       {
38626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38627       };
38628     }
38629   }
38630
38631   jresult = new Dali::Layer((const Dali::Layer &)result);
38632   return jresult;
38633 }
38634
38635
38636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38637   void * jresult ;
38638   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38639   Dali::Layer result;
38640
38641   arg1 = (Dali::Stage *)jarg1;
38642   {
38643     try {
38644       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38645     } catch (std::out_of_range& e) {
38646       {
38647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38648       };
38649     } catch (std::exception& e) {
38650       {
38651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38652       };
38653     } catch (Dali::DaliException e) {
38654       {
38655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38656       };
38657     } catch (...) {
38658       {
38659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38660       };
38661     }
38662   }
38663
38664   jresult = new Dali::Layer((const Dali::Layer &)result);
38665   return jresult;
38666 }
38667
38668
38669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38670   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38671   Dali::Vector4 arg2 ;
38672   Dali::Vector4 *argp2 ;
38673
38674   arg1 = (Dali::Stage *)jarg1;
38675   argp2 = (Dali::Vector4 *)jarg2;
38676   if (!argp2) {
38677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38678     return ;
38679   }
38680   arg2 = *argp2;
38681   {
38682     try {
38683       (arg1)->SetBackgroundColor(arg2);
38684     } catch (std::out_of_range& e) {
38685       {
38686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38687       };
38688     } catch (std::exception& e) {
38689       {
38690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38691       };
38692     } catch (Dali::DaliException e) {
38693       {
38694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38695       };
38696     } catch (...) {
38697       {
38698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38699       };
38700     }
38701   }
38702
38703 }
38704
38705
38706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38707   void * jresult ;
38708   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38709   Dali::Vector4 result;
38710
38711   arg1 = (Dali::Stage *)jarg1;
38712   {
38713     try {
38714       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38715     } catch (std::out_of_range& e) {
38716       {
38717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38718       };
38719     } catch (std::exception& e) {
38720       {
38721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38722       };
38723     } catch (Dali::DaliException e) {
38724       {
38725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38726       };
38727     } catch (...) {
38728       {
38729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38730       };
38731     }
38732   }
38733
38734   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38735   return jresult;
38736 }
38737
38738
38739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38740   void * jresult ;
38741   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38742   Dali::Vector2 result;
38743
38744   arg1 = (Dali::Stage *)jarg1;
38745   {
38746     try {
38747       result = ((Dali::Stage const *)arg1)->GetDpi();
38748     } catch (std::out_of_range& e) {
38749       {
38750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38751       };
38752     } catch (std::exception& e) {
38753       {
38754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38755       };
38756     } catch (Dali::DaliException e) {
38757       {
38758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38759       };
38760     } catch (...) {
38761       {
38762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38763       };
38764     }
38765   }
38766
38767   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38768   return jresult;
38769 }
38770
38771
38772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38773   void * jresult ;
38774   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38775   Dali::ObjectRegistry result;
38776
38777   arg1 = (Dali::Stage *)jarg1;
38778   {
38779     try {
38780       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38781     } catch (std::out_of_range& e) {
38782       {
38783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38784       };
38785     } catch (std::exception& e) {
38786       {
38787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38788       };
38789     } catch (Dali::DaliException e) {
38790       {
38791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38792       };
38793     } catch (...) {
38794       {
38795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38796       };
38797     }
38798   }
38799
38800   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38801   return jresult;
38802 }
38803
38804
38805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38806   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38807   float arg2 ;
38808
38809   arg1 = (Dali::Stage *)jarg1;
38810   arg2 = (float)jarg2;
38811   {
38812     try {
38813       (arg1)->KeepRendering(arg2);
38814     } catch (std::out_of_range& e) {
38815       {
38816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38817       };
38818     } catch (std::exception& e) {
38819       {
38820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38821       };
38822     } catch (Dali::DaliException e) {
38823       {
38824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38825       };
38826     } catch (...) {
38827       {
38828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38829       };
38830     }
38831   }
38832
38833 }
38834
38835
38836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38837   void * jresult ;
38838   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38839   Dali::Stage::KeyEventSignalType *result = 0 ;
38840
38841   arg1 = (Dali::Stage *)jarg1;
38842   {
38843     try {
38844       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38845     } catch (std::out_of_range& e) {
38846       {
38847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38848       };
38849     } catch (std::exception& e) {
38850       {
38851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38852       };
38853     } catch (Dali::DaliException e) {
38854       {
38855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38856       };
38857     } catch (...) {
38858       {
38859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38860       };
38861     }
38862   }
38863
38864   jresult = (void *)result;
38865   return jresult;
38866 }
38867
38868
38869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38870   void * jresult ;
38871   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38872   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38873
38874   arg1 = (Dali::Stage *)jarg1;
38875   {
38876     try {
38877       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38878     } catch (std::out_of_range& e) {
38879       {
38880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38881       };
38882     } catch (std::exception& e) {
38883       {
38884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38885       };
38886     } catch (Dali::DaliException e) {
38887       {
38888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38889       };
38890     } catch (...) {
38891       {
38892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38893       };
38894     }
38895   }
38896
38897   jresult = (void *)result;
38898   return jresult;
38899 }
38900
38901
38902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38903   void * jresult ;
38904   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38905   Dali::Stage::TouchSignalType *result = 0 ;
38906
38907   arg1 = (Dali::Stage *)jarg1;
38908   {
38909     try {
38910       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38911     } catch (std::out_of_range& e) {
38912       {
38913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38914       };
38915     } catch (std::exception& e) {
38916       {
38917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38918       };
38919     } catch (Dali::DaliException e) {
38920       {
38921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38922       };
38923     } catch (...) {
38924       {
38925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38926       };
38927     }
38928   }
38929
38930   jresult = (void *)result;
38931   return jresult;
38932 }
38933
38934
38935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38936   void * jresult ;
38937   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38938   Dali::Stage::WheelEventSignalType *result = 0 ;
38939
38940   arg1 = (Dali::Stage *)jarg1;
38941   {
38942     try {
38943       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38944     } catch (std::out_of_range& e) {
38945       {
38946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38947       };
38948     } catch (std::exception& e) {
38949       {
38950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38951       };
38952     } catch (Dali::DaliException e) {
38953       {
38954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38955       };
38956     } catch (...) {
38957       {
38958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38959       };
38960     }
38961   }
38962
38963   jresult = (void *)result;
38964   return jresult;
38965 }
38966
38967
38968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38969   void * jresult ;
38970   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38971   Dali::Stage::ContextStatusSignal *result = 0 ;
38972
38973   arg1 = (Dali::Stage *)jarg1;
38974   {
38975     try {
38976       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38977     } catch (std::out_of_range& e) {
38978       {
38979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38980       };
38981     } catch (std::exception& e) {
38982       {
38983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38984       };
38985     } catch (Dali::DaliException e) {
38986       {
38987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38988       };
38989     } catch (...) {
38990       {
38991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38992       };
38993     }
38994   }
38995
38996   jresult = (void *)result;
38997   return jresult;
38998 }
38999
39000
39001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39002   void * jresult ;
39003   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39004   Dali::Stage::ContextStatusSignal *result = 0 ;
39005
39006   arg1 = (Dali::Stage *)jarg1;
39007   {
39008     try {
39009       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39010     } catch (std::out_of_range& e) {
39011       {
39012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39013       };
39014     } catch (std::exception& e) {
39015       {
39016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39017       };
39018     } catch (Dali::DaliException e) {
39019       {
39020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39021       };
39022     } catch (...) {
39023       {
39024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39025       };
39026     }
39027   }
39028
39029   jresult = (void *)result;
39030   return jresult;
39031 }
39032
39033
39034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39035   void * jresult ;
39036   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39037   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39038
39039   arg1 = (Dali::Stage *)jarg1;
39040   {
39041     try {
39042       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39043     } catch (std::out_of_range& e) {
39044       {
39045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39046       };
39047     } catch (std::exception& e) {
39048       {
39049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39050       };
39051     } catch (Dali::DaliException e) {
39052       {
39053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39054       };
39055     } catch (...) {
39056       {
39057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39058       };
39059     }
39060   }
39061
39062   jresult = (void *)result;
39063   return jresult;
39064 }
39065
39066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39067   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39068   Dali::DevelStage::Rendering arg2 ;
39069
39070   arg1 = (Dali::Stage *)jarg1;
39071   arg2 = (Dali::DevelStage::Rendering)jarg2;
39072   {
39073     try {
39074       DevelStage::SetRenderingBehavior(*arg1,arg2);
39075     } catch (std::out_of_range& e) {
39076       {
39077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39078       };
39079     } catch (std::exception& e) {
39080       {
39081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39082       };
39083     } catch (Dali::DaliException e) {
39084       {
39085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39086       };
39087     } catch (...) {
39088       {
39089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39090       };
39091     }
39092   }
39093
39094 }
39095
39096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39097
39098   int jresult ;
39099   int result ;
39100   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39101
39102   arg1 = (Dali::Stage *)jarg1;
39103   {
39104     try {
39105       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39106     } catch (std::out_of_range& e) {
39107       {
39108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39109       };
39110     } catch (std::exception& e) {
39111       {
39112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39113       };
39114     } catch (Dali::DaliException e) {
39115       {
39116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39117       };
39118     } catch (...) {
39119       {
39120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39121       };
39122     }
39123   }
39124
39125   jresult = result;
39126   return jresult;
39127 }
39128
39129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39130   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39131
39132   arg1 = (Dali::RelayoutContainer *)jarg1;
39133   {
39134     try {
39135       delete arg1;
39136     } catch (std::out_of_range& e) {
39137       {
39138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39139       };
39140     } catch (std::exception& e) {
39141       {
39142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39143       };
39144     } catch (Dali::DaliException e) {
39145       {
39146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39147       };
39148     } catch (...) {
39149       {
39150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39151       };
39152     }
39153   }
39154
39155 }
39156
39157
39158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39159   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39160   Dali::Actor *arg2 = 0 ;
39161   Dali::Vector2 *arg3 = 0 ;
39162
39163   arg1 = (Dali::RelayoutContainer *)jarg1;
39164   arg2 = (Dali::Actor *)jarg2;
39165   if (!arg2) {
39166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39167     return ;
39168   }
39169   arg3 = (Dali::Vector2 *)jarg3;
39170   if (!arg3) {
39171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39172     return ;
39173   }
39174   {
39175     try {
39176       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39177     } catch (std::out_of_range& e) {
39178       {
39179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39180       };
39181     } catch (std::exception& e) {
39182       {
39183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39184       };
39185     } catch (Dali::DaliException e) {
39186       {
39187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39188       };
39189     } catch (...) {
39190       {
39191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39192       };
39193     }
39194   }
39195
39196 }
39197
39198
39199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39200   void * jresult ;
39201   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39202   Dali::CustomActor result;
39203
39204   arg1 = (Dali::CustomActorImpl *)jarg1;
39205   {
39206     try {
39207       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39208     } catch (std::out_of_range& e) {
39209       {
39210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39211       };
39212     } catch (std::exception& e) {
39213       {
39214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39215       };
39216     } catch (Dali::DaliException e) {
39217       {
39218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39219       };
39220     } catch (...) {
39221       {
39222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39223       };
39224     }
39225   }
39226
39227   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39228   return jresult;
39229 }
39230
39231
39232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39233   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39234   int arg2 ;
39235
39236   arg1 = (Dali::CustomActorImpl *)jarg1;
39237   arg2 = (int)jarg2;
39238   {
39239     try {
39240       (arg1)->OnStageConnection(arg2);
39241     } catch (std::out_of_range& e) {
39242       {
39243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39244       };
39245     } catch (std::exception& e) {
39246       {
39247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39248       };
39249     } catch (Dali::DaliException e) {
39250       {
39251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39252       };
39253     } catch (...) {
39254       {
39255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39256       };
39257     }
39258   }
39259
39260 }
39261
39262
39263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39264   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39265
39266   arg1 = (Dali::CustomActorImpl *)jarg1;
39267   {
39268     try {
39269       (arg1)->OnStageDisconnection();
39270     } catch (std::out_of_range& e) {
39271       {
39272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39273       };
39274     } catch (std::exception& e) {
39275       {
39276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39277       };
39278     } catch (Dali::DaliException e) {
39279       {
39280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39281       };
39282     } catch (...) {
39283       {
39284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39285       };
39286     }
39287   }
39288
39289 }
39290
39291
39292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39293   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39294   Dali::Actor *arg2 = 0 ;
39295
39296   arg1 = (Dali::CustomActorImpl *)jarg1;
39297   arg2 = (Dali::Actor *)jarg2;
39298   if (!arg2) {
39299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39300     return ;
39301   }
39302   {
39303     try {
39304       (arg1)->OnChildAdd(*arg2);
39305     } catch (std::out_of_range& e) {
39306       {
39307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39308       };
39309     } catch (std::exception& e) {
39310       {
39311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39312       };
39313     } catch (Dali::DaliException e) {
39314       {
39315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39316       };
39317     } catch (...) {
39318       {
39319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39320       };
39321     }
39322   }
39323
39324 }
39325
39326
39327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39328   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39329   Dali::Actor *arg2 = 0 ;
39330
39331   arg1 = (Dali::CustomActorImpl *)jarg1;
39332   arg2 = (Dali::Actor *)jarg2;
39333   if (!arg2) {
39334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39335     return ;
39336   }
39337   {
39338     try {
39339       (arg1)->OnChildRemove(*arg2);
39340     } catch (std::out_of_range& e) {
39341       {
39342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39343       };
39344     } catch (std::exception& e) {
39345       {
39346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39347       };
39348     } catch (Dali::DaliException e) {
39349       {
39350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39351       };
39352     } catch (...) {
39353       {
39354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39355       };
39356     }
39357   }
39358
39359 }
39360
39361
39362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39363   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39364   Dali::Property::Index arg2 ;
39365   Dali::Property::Value arg3 ;
39366   Dali::Property::Value *argp3 ;
39367
39368   arg1 = (Dali::CustomActorImpl *)jarg1;
39369   arg2 = (Dali::Property::Index)jarg2;
39370   argp3 = (Dali::Property::Value *)jarg3;
39371   if (!argp3) {
39372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39373     return ;
39374   }
39375   arg3 = *argp3;
39376   {
39377     try {
39378       (arg1)->OnPropertySet(arg2,arg3);
39379     } catch (std::out_of_range& e) {
39380       {
39381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39382       };
39383     } catch (std::exception& e) {
39384       {
39385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39386       };
39387     } catch (Dali::DaliException e) {
39388       {
39389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39390       };
39391     } catch (...) {
39392       {
39393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39394       };
39395     }
39396   }
39397
39398 }
39399
39400
39401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39402   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39403   Dali::Vector3 *arg2 = 0 ;
39404
39405   arg1 = (Dali::CustomActorImpl *)jarg1;
39406   arg2 = (Dali::Vector3 *)jarg2;
39407   if (!arg2) {
39408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39409     return ;
39410   }
39411   {
39412     try {
39413       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39414     } catch (std::out_of_range& e) {
39415       {
39416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39417       };
39418     } catch (std::exception& e) {
39419       {
39420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39421       };
39422     } catch (Dali::DaliException e) {
39423       {
39424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39425       };
39426     } catch (...) {
39427       {
39428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39429       };
39430     }
39431   }
39432
39433 }
39434
39435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39436   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39437   Dali::Animation *arg2 = 0 ;
39438   Dali::Vector3 *arg3 = 0 ;
39439
39440   arg1 = (Dali::CustomActorImpl *)jarg1;
39441   arg2 = (Dali::Animation *)jarg2;
39442   if (!arg2) {
39443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39444     return ;
39445   }
39446   arg3 = (Dali::Vector3 *)jarg3;
39447   if (!arg3) {
39448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39449     return ;
39450   }
39451   {
39452     try {
39453       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39454     } catch (std::out_of_range& e) {
39455       {
39456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39457       };
39458     } catch (std::exception& e) {
39459       {
39460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39461       };
39462     } catch (Dali::DaliException e) {
39463       {
39464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39465       };
39466     } catch (...) {
39467       {
39468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39469       };
39470     }
39471   }
39472
39473 }
39474
39475
39476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39477   unsigned int jresult ;
39478   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39479   Dali::TouchEvent *arg2 = 0 ;
39480   bool result;
39481
39482   arg1 = (Dali::CustomActorImpl *)jarg1;
39483   arg2 = (Dali::TouchEvent *)jarg2;
39484   if (!arg2) {
39485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39486     return 0;
39487   }
39488   {
39489     try {
39490       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39491     } catch (std::out_of_range& e) {
39492       {
39493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39494       };
39495     } catch (std::exception& e) {
39496       {
39497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39498       };
39499     } catch (Dali::DaliException e) {
39500       {
39501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39502       };
39503     } catch (...) {
39504       {
39505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39506       };
39507     }
39508   }
39509
39510   jresult = result;
39511   return jresult;
39512 }
39513
39514
39515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39516   unsigned int jresult ;
39517   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39518   Dali::HoverEvent *arg2 = 0 ;
39519   bool result;
39520
39521   arg1 = (Dali::CustomActorImpl *)jarg1;
39522   arg2 = (Dali::HoverEvent *)jarg2;
39523   if (!arg2) {
39524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39525     return 0;
39526   }
39527   {
39528     try {
39529       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39530     } catch (std::out_of_range& e) {
39531       {
39532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39533       };
39534     } catch (std::exception& e) {
39535       {
39536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39537       };
39538     } catch (Dali::DaliException e) {
39539       {
39540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39541       };
39542     } catch (...) {
39543       {
39544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39545       };
39546     }
39547   }
39548
39549   jresult = result;
39550   return jresult;
39551 }
39552
39553
39554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39555   unsigned int jresult ;
39556   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39557   Dali::KeyEvent *arg2 = 0 ;
39558   bool result;
39559
39560   arg1 = (Dali::CustomActorImpl *)jarg1;
39561   arg2 = (Dali::KeyEvent *)jarg2;
39562   if (!arg2) {
39563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39564     return 0;
39565   }
39566   {
39567     try {
39568       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39569     } catch (std::out_of_range& e) {
39570       {
39571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39572       };
39573     } catch (std::exception& e) {
39574       {
39575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39576       };
39577     } catch (Dali::DaliException e) {
39578       {
39579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39580       };
39581     } catch (...) {
39582       {
39583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39584       };
39585     }
39586   }
39587
39588   jresult = result;
39589   return jresult;
39590 }
39591
39592
39593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39594   unsigned int jresult ;
39595   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39596   Dali::WheelEvent *arg2 = 0 ;
39597   bool result;
39598
39599   arg1 = (Dali::CustomActorImpl *)jarg1;
39600   arg2 = (Dali::WheelEvent *)jarg2;
39601   if (!arg2) {
39602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39603     return 0;
39604   }
39605   {
39606     try {
39607       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39608     } catch (std::out_of_range& e) {
39609       {
39610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39611       };
39612     } catch (std::exception& e) {
39613       {
39614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39615       };
39616     } catch (Dali::DaliException e) {
39617       {
39618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39619       };
39620     } catch (...) {
39621       {
39622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39623       };
39624     }
39625   }
39626
39627   jresult = result;
39628   return jresult;
39629 }
39630
39631
39632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39633   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39634   Dali::Vector2 *arg2 = 0 ;
39635   Dali::RelayoutContainer *arg3 = 0 ;
39636
39637   arg1 = (Dali::CustomActorImpl *)jarg1;
39638   arg2 = (Dali::Vector2 *)jarg2;
39639   if (!arg2) {
39640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39641     return ;
39642   }
39643   arg3 = (Dali::RelayoutContainer *)jarg3;
39644   if (!arg3) {
39645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39646     return ;
39647   }
39648   {
39649     try {
39650       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39651     } catch (std::out_of_range& e) {
39652       {
39653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39654       };
39655     } catch (std::exception& e) {
39656       {
39657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39658       };
39659     } catch (Dali::DaliException e) {
39660       {
39661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39662       };
39663     } catch (...) {
39664       {
39665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39666       };
39667     }
39668   }
39669
39670 }
39671
39672
39673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39674   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39675   Dali::ResizePolicy::Type arg2 ;
39676   Dali::Dimension::Type arg3 ;
39677
39678   arg1 = (Dali::CustomActorImpl *)jarg1;
39679   arg2 = (Dali::ResizePolicy::Type)jarg2;
39680   arg3 = (Dali::Dimension::Type)jarg3;
39681   {
39682     try {
39683       (arg1)->OnSetResizePolicy(arg2,arg3);
39684     } catch (std::out_of_range& e) {
39685       {
39686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39687       };
39688     } catch (std::exception& e) {
39689       {
39690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39691       };
39692     } catch (Dali::DaliException e) {
39693       {
39694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39695       };
39696     } catch (...) {
39697       {
39698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39699       };
39700     }
39701   }
39702
39703 }
39704
39705
39706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39707   void * jresult ;
39708   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39709   Dali::Vector3 result;
39710
39711   arg1 = (Dali::CustomActorImpl *)jarg1;
39712   {
39713     try {
39714       result = (arg1)->GetNaturalSize();
39715     } catch (std::out_of_range& e) {
39716       {
39717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39718       };
39719     } catch (std::exception& e) {
39720       {
39721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39722       };
39723     } catch (Dali::DaliException e) {
39724       {
39725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39726       };
39727     } catch (...) {
39728       {
39729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39730       };
39731     }
39732   }
39733
39734   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39735   return jresult;
39736 }
39737
39738
39739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39740   float jresult ;
39741   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39742   Dali::Actor *arg2 = 0 ;
39743   Dali::Dimension::Type arg3 ;
39744   float result;
39745
39746   arg1 = (Dali::CustomActorImpl *)jarg1;
39747   arg2 = (Dali::Actor *)jarg2;
39748   if (!arg2) {
39749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39750     return 0;
39751   }
39752   arg3 = (Dali::Dimension::Type)jarg3;
39753   {
39754     try {
39755       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39756     } catch (std::out_of_range& e) {
39757       {
39758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39759       };
39760     } catch (std::exception& e) {
39761       {
39762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39763       };
39764     } catch (Dali::DaliException e) {
39765       {
39766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39767       };
39768     } catch (...) {
39769       {
39770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39771       };
39772     }
39773   }
39774
39775   jresult = result;
39776   return jresult;
39777 }
39778
39779
39780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39781   float jresult ;
39782   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39783   float arg2 ;
39784   float result;
39785
39786   arg1 = (Dali::CustomActorImpl *)jarg1;
39787   arg2 = (float)jarg2;
39788   {
39789     try {
39790       result = (float)(arg1)->GetHeightForWidth(arg2);
39791     } catch (std::out_of_range& e) {
39792       {
39793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39794       };
39795     } catch (std::exception& e) {
39796       {
39797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39798       };
39799     } catch (Dali::DaliException e) {
39800       {
39801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39802       };
39803     } catch (...) {
39804       {
39805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39806       };
39807     }
39808   }
39809
39810   jresult = result;
39811   return jresult;
39812 }
39813
39814
39815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39816   float jresult ;
39817   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39818   float arg2 ;
39819   float result;
39820
39821   arg1 = (Dali::CustomActorImpl *)jarg1;
39822   arg2 = (float)jarg2;
39823   {
39824     try {
39825       result = (float)(arg1)->GetWidthForHeight(arg2);
39826     } catch (std::out_of_range& e) {
39827       {
39828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39829       };
39830     } catch (std::exception& e) {
39831       {
39832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39833       };
39834     } catch (Dali::DaliException e) {
39835       {
39836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39837       };
39838     } catch (...) {
39839       {
39840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39841       };
39842     }
39843   }
39844
39845   jresult = result;
39846   return jresult;
39847 }
39848
39849
39850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39851   unsigned int jresult ;
39852   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39853   Dali::Dimension::Type arg2 ;
39854   bool result;
39855
39856   arg1 = (Dali::CustomActorImpl *)jarg1;
39857   arg2 = (Dali::Dimension::Type)jarg2;
39858   {
39859     try {
39860       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39861     } catch (std::out_of_range& e) {
39862       {
39863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39864       };
39865     } catch (std::exception& e) {
39866       {
39867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39868       };
39869     } catch (Dali::DaliException e) {
39870       {
39871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39872       };
39873     } catch (...) {
39874       {
39875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39876       };
39877     }
39878   }
39879
39880   jresult = result;
39881   return jresult;
39882 }
39883
39884
39885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39886   unsigned int jresult ;
39887   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39888   bool result;
39889
39890   arg1 = (Dali::CustomActorImpl *)jarg1;
39891   {
39892     try {
39893       result = (bool)(arg1)->RelayoutDependentOnChildren();
39894     } catch (std::out_of_range& e) {
39895       {
39896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39897       };
39898     } catch (std::exception& e) {
39899       {
39900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39901       };
39902     } catch (Dali::DaliException e) {
39903       {
39904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39905       };
39906     } catch (...) {
39907       {
39908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39909       };
39910     }
39911   }
39912
39913   jresult = result;
39914   return jresult;
39915 }
39916
39917
39918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39919   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39920   Dali::Dimension::Type arg2 ;
39921
39922   arg1 = (Dali::CustomActorImpl *)jarg1;
39923   arg2 = (Dali::Dimension::Type)jarg2;
39924   {
39925     try {
39926       (arg1)->OnCalculateRelayoutSize(arg2);
39927     } catch (std::out_of_range& e) {
39928       {
39929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39930       };
39931     } catch (std::exception& e) {
39932       {
39933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39934       };
39935     } catch (Dali::DaliException e) {
39936       {
39937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39938       };
39939     } catch (...) {
39940       {
39941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39942       };
39943     }
39944   }
39945
39946 }
39947
39948
39949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39950   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39951   float arg2 ;
39952   Dali::Dimension::Type arg3 ;
39953
39954   arg1 = (Dali::CustomActorImpl *)jarg1;
39955   arg2 = (float)jarg2;
39956   arg3 = (Dali::Dimension::Type)jarg3;
39957   {
39958     try {
39959       (arg1)->OnLayoutNegotiated(arg2,arg3);
39960     } catch (std::out_of_range& e) {
39961       {
39962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39963       };
39964     } catch (std::exception& e) {
39965       {
39966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39967       };
39968     } catch (Dali::DaliException e) {
39969       {
39970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39971       };
39972     } catch (...) {
39973       {
39974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39975       };
39976     }
39977   }
39978
39979 }
39980
39981
39982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39983   unsigned int jresult ;
39984   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39985   bool result;
39986
39987   arg1 = (Dali::CustomActorImpl *)jarg1;
39988   {
39989     try {
39990       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39991     } catch (std::out_of_range& e) {
39992       {
39993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39994       };
39995     } catch (std::exception& e) {
39996       {
39997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39998       };
39999     } catch (Dali::DaliException e) {
40000       {
40001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40002       };
40003     } catch (...) {
40004       {
40005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40006       };
40007     }
40008   }
40009
40010   jresult = result;
40011   return jresult;
40012 }
40013
40014
40015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40016   unsigned int jresult ;
40017   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40018   bool result;
40019
40020   arg1 = (Dali::CustomActorImpl *)jarg1;
40021   {
40022     try {
40023       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40024     } catch (std::out_of_range& e) {
40025       {
40026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40027       };
40028     } catch (std::exception& e) {
40029       {
40030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40031       };
40032     } catch (Dali::DaliException e) {
40033       {
40034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40035       };
40036     } catch (...) {
40037       {
40038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40039       };
40040     }
40041   }
40042
40043   jresult = result;
40044   return jresult;
40045 }
40046
40047
40048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40049   unsigned int jresult ;
40050   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40051   bool result;
40052
40053   arg1 = (Dali::CustomActorImpl *)jarg1;
40054   {
40055     try {
40056       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40057     } catch (std::out_of_range& e) {
40058       {
40059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40060       };
40061     } catch (std::exception& e) {
40062       {
40063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40064       };
40065     } catch (Dali::DaliException e) {
40066       {
40067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40068       };
40069     } catch (...) {
40070       {
40071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40072       };
40073     }
40074   }
40075
40076   jresult = result;
40077   return jresult;
40078 }
40079
40080
40081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40082   unsigned int jresult ;
40083   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40084   bool result;
40085
40086   arg1 = (Dali::CustomActorImpl *)jarg1;
40087   {
40088     try {
40089       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40090     } catch (std::out_of_range& e) {
40091       {
40092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40093       };
40094     } catch (std::exception& e) {
40095       {
40096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40097       };
40098     } catch (Dali::DaliException e) {
40099       {
40100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40101       };
40102     } catch (...) {
40103       {
40104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40105       };
40106     }
40107   }
40108
40109   jresult = result;
40110   return jresult;
40111 }
40112
40113
40114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40115   void * jresult ;
40116   Dali::CustomActor *result = 0 ;
40117
40118   {
40119     try {
40120       result = (Dali::CustomActor *)new Dali::CustomActor();
40121     } catch (std::out_of_range& e) {
40122       {
40123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40124       };
40125     } catch (std::exception& e) {
40126       {
40127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40128       };
40129     } catch (Dali::DaliException e) {
40130       {
40131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40132       };
40133     } catch (...) {
40134       {
40135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40136       };
40137     }
40138   }
40139
40140   jresult = (void *)result;
40141   return jresult;
40142 }
40143
40144
40145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40146   void * jresult ;
40147   Dali::BaseHandle arg1 ;
40148   Dali::BaseHandle *argp1 ;
40149   Dali::CustomActor result;
40150
40151   argp1 = (Dali::BaseHandle *)jarg1;
40152   if (!argp1) {
40153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40154     return 0;
40155   }
40156   arg1 = *argp1;
40157   {
40158     try {
40159       result = Dali::CustomActor::DownCast(arg1);
40160     } catch (std::out_of_range& e) {
40161       {
40162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40163       };
40164     } catch (std::exception& e) {
40165       {
40166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40167       };
40168     } catch (Dali::DaliException e) {
40169       {
40170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40171       };
40172     } catch (...) {
40173       {
40174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40175       };
40176     }
40177   }
40178
40179   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40180   return jresult;
40181 }
40182
40183
40184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40185   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40186
40187   arg1 = (Dali::CustomActor *)jarg1;
40188   {
40189     try {
40190       delete arg1;
40191     } catch (std::out_of_range& e) {
40192       {
40193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40194       };
40195     } catch (std::exception& e) {
40196       {
40197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40198       };
40199     } catch (Dali::DaliException e) {
40200       {
40201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40202       };
40203     } catch (...) {
40204       {
40205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40206       };
40207     }
40208   }
40209
40210 }
40211
40212
40213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40214   void * jresult ;
40215   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40216   Dali::CustomActorImpl *result = 0 ;
40217
40218   arg1 = (Dali::CustomActor *)jarg1;
40219   {
40220     try {
40221       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40222     } catch (std::out_of_range& e) {
40223       {
40224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40225       };
40226     } catch (std::exception& e) {
40227       {
40228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40229       };
40230     } catch (Dali::DaliException e) {
40231       {
40232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40233       };
40234     } catch (...) {
40235       {
40236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40237       };
40238     }
40239   }
40240
40241   jresult = (void *)result;
40242   return jresult;
40243 }
40244
40245
40246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40247   void * jresult ;
40248   Dali::CustomActorImpl *arg1 = 0 ;
40249   Dali::CustomActor *result = 0 ;
40250
40251   arg1 = (Dali::CustomActorImpl *)jarg1;
40252   if (!arg1) {
40253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40254     return 0;
40255   }
40256   {
40257     try {
40258       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40259     } catch (std::out_of_range& e) {
40260       {
40261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40262       };
40263     } catch (std::exception& e) {
40264       {
40265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40266       };
40267     } catch (Dali::DaliException e) {
40268       {
40269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40270       };
40271     } catch (...) {
40272       {
40273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40274       };
40275     }
40276   }
40277
40278   jresult = (void *)result;
40279   return jresult;
40280 }
40281
40282
40283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40284   void * jresult ;
40285   Dali::CustomActor *arg1 = 0 ;
40286   Dali::CustomActor *result = 0 ;
40287
40288   arg1 = (Dali::CustomActor *)jarg1;
40289   if (!arg1) {
40290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40291     return 0;
40292   }
40293   {
40294     try {
40295       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40296     } catch (std::out_of_range& e) {
40297       {
40298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40299       };
40300     } catch (std::exception& e) {
40301       {
40302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40303       };
40304     } catch (Dali::DaliException e) {
40305       {
40306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40307       };
40308     } catch (...) {
40309       {
40310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40311       };
40312     }
40313   }
40314
40315   jresult = (void *)result;
40316   return jresult;
40317 }
40318
40319
40320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40321   void * jresult ;
40322   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40323   Dali::CustomActor *arg2 = 0 ;
40324   Dali::CustomActor *result = 0 ;
40325
40326   arg1 = (Dali::CustomActor *)jarg1;
40327   arg2 = (Dali::CustomActor *)jarg2;
40328   if (!arg2) {
40329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40330     return 0;
40331   }
40332   {
40333     try {
40334       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40335     } catch (std::out_of_range& e) {
40336       {
40337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40338       };
40339     } catch (std::exception& e) {
40340       {
40341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40342       };
40343     } catch (Dali::DaliException e) {
40344       {
40345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40346       };
40347     } catch (...) {
40348       {
40349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40350       };
40351     }
40352   }
40353
40354   jresult = (void *)result;
40355   return jresult;
40356 }
40357
40358
40359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40360   int jresult ;
40361   int result;
40362
40363   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40364   jresult = (int)result;
40365   return jresult;
40366 }
40367
40368
40369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40370   int jresult ;
40371   int result;
40372
40373   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40374   jresult = (int)result;
40375   return jresult;
40376 }
40377
40378
40379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40380   int jresult ;
40381   int result;
40382
40383   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40384   jresult = (int)result;
40385   return jresult;
40386 }
40387
40388
40389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40390   int jresult ;
40391   int result;
40392
40393   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40394   jresult = (int)result;
40395   return jresult;
40396 }
40397
40398
40399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40400   int jresult ;
40401   int result;
40402
40403   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40404   jresult = (int)result;
40405   return jresult;
40406 }
40407
40408
40409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40410   int jresult ;
40411   int result;
40412
40413   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40414   jresult = (int)result;
40415   return jresult;
40416 }
40417
40418
40419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40420   int jresult ;
40421   int result;
40422
40423   result = (int)Dali::PanGestureDetector::Property::PANNING;
40424   jresult = (int)result;
40425   return jresult;
40426 }
40427
40428
40429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40430   void * jresult ;
40431   Dali::PanGestureDetector::Property *result = 0 ;
40432
40433   {
40434     try {
40435       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40436     } catch (std::out_of_range& e) {
40437       {
40438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40439       };
40440     } catch (std::exception& e) {
40441       {
40442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40443       };
40444     } catch (Dali::DaliException e) {
40445       {
40446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40447       };
40448     } catch (...) {
40449       {
40450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40451       };
40452     }
40453   }
40454
40455   jresult = (void *)result;
40456   return jresult;
40457 }
40458
40459
40460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40461   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40462
40463   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40464   {
40465     try {
40466       delete arg1;
40467     } catch (std::out_of_range& e) {
40468       {
40469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40470       };
40471     } catch (std::exception& e) {
40472       {
40473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40474       };
40475     } catch (Dali::DaliException e) {
40476       {
40477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40478       };
40479     } catch (...) {
40480       {
40481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40482       };
40483     }
40484   }
40485
40486 }
40487
40488
40489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40490   void * jresult ;
40491   Dali::Radian *result = 0 ;
40492
40493   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40494   jresult = (void *)result;
40495   return jresult;
40496 }
40497
40498
40499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40500   void * jresult ;
40501   Dali::Radian *result = 0 ;
40502
40503   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40504   jresult = (void *)result;
40505   return jresult;
40506 }
40507
40508
40509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40510   void * jresult ;
40511   Dali::Radian *result = 0 ;
40512
40513   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40514   jresult = (void *)result;
40515   return jresult;
40516 }
40517
40518
40519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40520   void * jresult ;
40521   Dali::Radian *result = 0 ;
40522
40523   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40524   jresult = (void *)result;
40525   return jresult;
40526 }
40527
40528
40529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40530   void * jresult ;
40531   Dali::Radian *result = 0 ;
40532
40533   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40534   jresult = (void *)result;
40535   return jresult;
40536 }
40537
40538
40539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40540   void * jresult ;
40541   Dali::Radian *result = 0 ;
40542
40543   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40544   jresult = (void *)result;
40545   return jresult;
40546 }
40547
40548
40549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40550   void * jresult ;
40551   Dali::Radian *result = 0 ;
40552
40553   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40554   jresult = (void *)result;
40555   return jresult;
40556 }
40557
40558
40559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40560   void * jresult ;
40561   Dali::PanGestureDetector *result = 0 ;
40562
40563   {
40564     try {
40565       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40566     } catch (std::out_of_range& e) {
40567       {
40568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40569       };
40570     } catch (std::exception& e) {
40571       {
40572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40573       };
40574     } catch (Dali::DaliException e) {
40575       {
40576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40577       };
40578     } catch (...) {
40579       {
40580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40581       };
40582     }
40583   }
40584
40585   jresult = (void *)result;
40586   return jresult;
40587 }
40588
40589
40590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40591   void * jresult ;
40592   Dali::PanGestureDetector result;
40593
40594   {
40595     try {
40596       result = Dali::PanGestureDetector::New();
40597     } catch (std::out_of_range& e) {
40598       {
40599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40600       };
40601     } catch (std::exception& e) {
40602       {
40603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40604       };
40605     } catch (Dali::DaliException e) {
40606       {
40607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40608       };
40609     } catch (...) {
40610       {
40611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40612       };
40613     }
40614   }
40615
40616   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40617   return jresult;
40618 }
40619
40620
40621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40622   void * jresult ;
40623   Dali::BaseHandle arg1 ;
40624   Dali::BaseHandle *argp1 ;
40625   Dali::PanGestureDetector result;
40626
40627   argp1 = (Dali::BaseHandle *)jarg1;
40628   if (!argp1) {
40629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40630     return 0;
40631   }
40632   arg1 = *argp1;
40633   {
40634     try {
40635       result = Dali::PanGestureDetector::DownCast(arg1);
40636     } catch (std::out_of_range& e) {
40637       {
40638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40639       };
40640     } catch (std::exception& e) {
40641       {
40642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40643       };
40644     } catch (Dali::DaliException e) {
40645       {
40646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40647       };
40648     } catch (...) {
40649       {
40650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40651       };
40652     }
40653   }
40654
40655   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40656   return jresult;
40657 }
40658
40659
40660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40661   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40662
40663   arg1 = (Dali::PanGestureDetector *)jarg1;
40664   {
40665     try {
40666       delete arg1;
40667     } catch (std::out_of_range& e) {
40668       {
40669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40670       };
40671     } catch (std::exception& e) {
40672       {
40673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40674       };
40675     } catch (Dali::DaliException e) {
40676       {
40677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40678       };
40679     } catch (...) {
40680       {
40681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40682       };
40683     }
40684   }
40685
40686 }
40687
40688
40689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40690   void * jresult ;
40691   Dali::PanGestureDetector *arg1 = 0 ;
40692   Dali::PanGestureDetector *result = 0 ;
40693
40694   arg1 = (Dali::PanGestureDetector *)jarg1;
40695   if (!arg1) {
40696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40697     return 0;
40698   }
40699   {
40700     try {
40701       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40702     } catch (std::out_of_range& e) {
40703       {
40704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40705       };
40706     } catch (std::exception& e) {
40707       {
40708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40709       };
40710     } catch (Dali::DaliException e) {
40711       {
40712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40713       };
40714     } catch (...) {
40715       {
40716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40717       };
40718     }
40719   }
40720
40721   jresult = (void *)result;
40722   return jresult;
40723 }
40724
40725
40726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40727   void * jresult ;
40728   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40729   Dali::PanGestureDetector *arg2 = 0 ;
40730   Dali::PanGestureDetector *result = 0 ;
40731
40732   arg1 = (Dali::PanGestureDetector *)jarg1;
40733   arg2 = (Dali::PanGestureDetector *)jarg2;
40734   if (!arg2) {
40735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40736     return 0;
40737   }
40738   {
40739     try {
40740       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40741     } catch (std::out_of_range& e) {
40742       {
40743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40744       };
40745     } catch (std::exception& e) {
40746       {
40747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40748       };
40749     } catch (Dali::DaliException e) {
40750       {
40751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40752       };
40753     } catch (...) {
40754       {
40755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40756       };
40757     }
40758   }
40759
40760   jresult = (void *)result;
40761   return jresult;
40762 }
40763
40764
40765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40766   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40767   unsigned int arg2 ;
40768
40769   arg1 = (Dali::PanGestureDetector *)jarg1;
40770   arg2 = (unsigned int)jarg2;
40771   {
40772     try {
40773       (arg1)->SetMinimumTouchesRequired(arg2);
40774     } catch (std::out_of_range& e) {
40775       {
40776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40777       };
40778     } catch (std::exception& e) {
40779       {
40780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40781       };
40782     } catch (Dali::DaliException e) {
40783       {
40784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40785       };
40786     } catch (...) {
40787       {
40788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40789       };
40790     }
40791   }
40792
40793 }
40794
40795
40796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40797   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40798   unsigned int arg2 ;
40799
40800   arg1 = (Dali::PanGestureDetector *)jarg1;
40801   arg2 = (unsigned int)jarg2;
40802   {
40803     try {
40804       (arg1)->SetMaximumTouchesRequired(arg2);
40805     } catch (std::out_of_range& e) {
40806       {
40807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40808       };
40809     } catch (std::exception& e) {
40810       {
40811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40812       };
40813     } catch (Dali::DaliException e) {
40814       {
40815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40816       };
40817     } catch (...) {
40818       {
40819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40820       };
40821     }
40822   }
40823
40824 }
40825
40826
40827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40828   unsigned int jresult ;
40829   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40830   unsigned int result;
40831
40832   arg1 = (Dali::PanGestureDetector *)jarg1;
40833   {
40834     try {
40835       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40836     } catch (std::out_of_range& e) {
40837       {
40838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40839       };
40840     } catch (std::exception& e) {
40841       {
40842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40843       };
40844     } catch (Dali::DaliException e) {
40845       {
40846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40847       };
40848     } catch (...) {
40849       {
40850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40851       };
40852     }
40853   }
40854
40855   jresult = result;
40856   return jresult;
40857 }
40858
40859
40860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40861   unsigned int jresult ;
40862   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40863   unsigned int result;
40864
40865   arg1 = (Dali::PanGestureDetector *)jarg1;
40866   {
40867     try {
40868       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40869     } catch (std::out_of_range& e) {
40870       {
40871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40872       };
40873     } catch (std::exception& e) {
40874       {
40875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40876       };
40877     } catch (Dali::DaliException e) {
40878       {
40879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40880       };
40881     } catch (...) {
40882       {
40883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40884       };
40885     }
40886   }
40887
40888   jresult = result;
40889   return jresult;
40890 }
40891
40892
40893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40894   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40895   Dali::Radian arg2 ;
40896   Dali::Radian arg3 ;
40897   Dali::Radian *argp2 ;
40898   Dali::Radian *argp3 ;
40899
40900   arg1 = (Dali::PanGestureDetector *)jarg1;
40901   argp2 = (Dali::Radian *)jarg2;
40902   if (!argp2) {
40903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40904     return ;
40905   }
40906   arg2 = *argp2;
40907   argp3 = (Dali::Radian *)jarg3;
40908   if (!argp3) {
40909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40910     return ;
40911   }
40912   arg3 = *argp3;
40913   {
40914     try {
40915       (arg1)->AddAngle(arg2,arg3);
40916     } catch (std::out_of_range& e) {
40917       {
40918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40919       };
40920     } catch (std::exception& e) {
40921       {
40922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40923       };
40924     } catch (Dali::DaliException e) {
40925       {
40926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40927       };
40928     } catch (...) {
40929       {
40930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40931       };
40932     }
40933   }
40934
40935 }
40936
40937
40938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40939   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40940   Dali::Radian arg2 ;
40941   Dali::Radian *argp2 ;
40942
40943   arg1 = (Dali::PanGestureDetector *)jarg1;
40944   argp2 = (Dali::Radian *)jarg2;
40945   if (!argp2) {
40946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40947     return ;
40948   }
40949   arg2 = *argp2;
40950   {
40951     try {
40952       (arg1)->AddAngle(arg2);
40953     } catch (std::out_of_range& e) {
40954       {
40955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40956       };
40957     } catch (std::exception& e) {
40958       {
40959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40960       };
40961     } catch (Dali::DaliException e) {
40962       {
40963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40964       };
40965     } catch (...) {
40966       {
40967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40968       };
40969     }
40970   }
40971
40972 }
40973
40974
40975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40976   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40977   Dali::Radian arg2 ;
40978   Dali::Radian arg3 ;
40979   Dali::Radian *argp2 ;
40980   Dali::Radian *argp3 ;
40981
40982   arg1 = (Dali::PanGestureDetector *)jarg1;
40983   argp2 = (Dali::Radian *)jarg2;
40984   if (!argp2) {
40985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40986     return ;
40987   }
40988   arg2 = *argp2;
40989   argp3 = (Dali::Radian *)jarg3;
40990   if (!argp3) {
40991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40992     return ;
40993   }
40994   arg3 = *argp3;
40995   {
40996     try {
40997       (arg1)->AddDirection(arg2,arg3);
40998     } catch (std::out_of_range& e) {
40999       {
41000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41001       };
41002     } catch (std::exception& e) {
41003       {
41004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41005       };
41006     } catch (Dali::DaliException e) {
41007       {
41008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41009       };
41010     } catch (...) {
41011       {
41012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41013       };
41014     }
41015   }
41016
41017 }
41018
41019
41020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41021   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41022   Dali::Radian arg2 ;
41023   Dali::Radian *argp2 ;
41024
41025   arg1 = (Dali::PanGestureDetector *)jarg1;
41026   argp2 = (Dali::Radian *)jarg2;
41027   if (!argp2) {
41028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41029     return ;
41030   }
41031   arg2 = *argp2;
41032   {
41033     try {
41034       (arg1)->AddDirection(arg2);
41035     } catch (std::out_of_range& e) {
41036       {
41037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41038       };
41039     } catch (std::exception& e) {
41040       {
41041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41042       };
41043     } catch (Dali::DaliException e) {
41044       {
41045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41046       };
41047     } catch (...) {
41048       {
41049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41050       };
41051     }
41052   }
41053
41054 }
41055
41056
41057 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41058   unsigned long jresult ;
41059   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41060   size_t result;
41061
41062   arg1 = (Dali::PanGestureDetector *)jarg1;
41063   {
41064     try {
41065       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41066     } catch (std::out_of_range& e) {
41067       {
41068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41069       };
41070     } catch (std::exception& e) {
41071       {
41072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41073       };
41074     } catch (Dali::DaliException e) {
41075       {
41076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41077       };
41078     } catch (...) {
41079       {
41080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41081       };
41082     }
41083   }
41084
41085   jresult = (unsigned long)result;
41086   return jresult;
41087 }
41088
41089
41090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41091   void * jresult ;
41092   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41093   size_t arg2 ;
41094   Dali::PanGestureDetector::AngleThresholdPair result;
41095
41096   arg1 = (Dali::PanGestureDetector *)jarg1;
41097   arg2 = (size_t)jarg2;
41098   {
41099     try {
41100       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41101     } catch (std::out_of_range& e) {
41102       {
41103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41104       };
41105     } catch (std::exception& e) {
41106       {
41107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41108       };
41109     } catch (Dali::DaliException e) {
41110       {
41111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41112       };
41113     } catch (...) {
41114       {
41115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41116       };
41117     }
41118   }
41119
41120   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41121   return jresult;
41122 }
41123
41124
41125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41126   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41127
41128   arg1 = (Dali::PanGestureDetector *)jarg1;
41129   {
41130     try {
41131       (arg1)->ClearAngles();
41132     } catch (std::out_of_range& e) {
41133       {
41134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41135       };
41136     } catch (std::exception& e) {
41137       {
41138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41139       };
41140     } catch (Dali::DaliException e) {
41141       {
41142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41143       };
41144     } catch (...) {
41145       {
41146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41147       };
41148     }
41149   }
41150
41151 }
41152
41153
41154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41155   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41156   Dali::Radian arg2 ;
41157   Dali::Radian *argp2 ;
41158
41159   arg1 = (Dali::PanGestureDetector *)jarg1;
41160   argp2 = (Dali::Radian *)jarg2;
41161   if (!argp2) {
41162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41163     return ;
41164   }
41165   arg2 = *argp2;
41166   {
41167     try {
41168       (arg1)->RemoveAngle(arg2);
41169     } catch (std::out_of_range& e) {
41170       {
41171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41172       };
41173     } catch (std::exception& e) {
41174       {
41175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41176       };
41177     } catch (Dali::DaliException e) {
41178       {
41179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41180       };
41181     } catch (...) {
41182       {
41183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41184       };
41185     }
41186   }
41187
41188 }
41189
41190
41191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41192   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41193   Dali::Radian arg2 ;
41194   Dali::Radian *argp2 ;
41195
41196   arg1 = (Dali::PanGestureDetector *)jarg1;
41197   argp2 = (Dali::Radian *)jarg2;
41198   if (!argp2) {
41199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41200     return ;
41201   }
41202   arg2 = *argp2;
41203   {
41204     try {
41205       (arg1)->RemoveDirection(arg2);
41206     } catch (std::out_of_range& e) {
41207       {
41208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41209       };
41210     } catch (std::exception& e) {
41211       {
41212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41213       };
41214     } catch (Dali::DaliException e) {
41215       {
41216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41217       };
41218     } catch (...) {
41219       {
41220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41221       };
41222     }
41223   }
41224
41225 }
41226
41227
41228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41229   void * jresult ;
41230   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41231   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41232
41233   arg1 = (Dali::PanGestureDetector *)jarg1;
41234   {
41235     try {
41236       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41237     } catch (std::out_of_range& e) {
41238       {
41239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41240       };
41241     } catch (std::exception& e) {
41242       {
41243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41244       };
41245     } catch (Dali::DaliException e) {
41246       {
41247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41248       };
41249     } catch (...) {
41250       {
41251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41252       };
41253     }
41254   }
41255
41256   jresult = (void *)result;
41257   return jresult;
41258 }
41259
41260
41261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41262   Dali::PanGesture *arg1 = 0 ;
41263
41264   arg1 = (Dali::PanGesture *)jarg1;
41265   if (!arg1) {
41266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41267     return ;
41268   }
41269   {
41270     try {
41271       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41272     } catch (std::out_of_range& e) {
41273       {
41274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41275       };
41276     } catch (std::exception& e) {
41277       {
41278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41279       };
41280     } catch (Dali::DaliException e) {
41281       {
41282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41283       };
41284     } catch (...) {
41285       {
41286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41287       };
41288     }
41289   }
41290
41291 }
41292
41293
41294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41295   void * jresult ;
41296   Dali::PanGesture *result = 0 ;
41297
41298   {
41299     try {
41300       result = (Dali::PanGesture *)new Dali::PanGesture();
41301     } catch (std::out_of_range& e) {
41302       {
41303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41304       };
41305     } catch (std::exception& e) {
41306       {
41307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41308       };
41309     } catch (Dali::DaliException e) {
41310       {
41311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41312       };
41313     } catch (...) {
41314       {
41315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41316       };
41317     }
41318   }
41319
41320   jresult = (void *)result;
41321   return jresult;
41322 }
41323
41324
41325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41326   void * jresult ;
41327   Dali::Gesture::State arg1 ;
41328   Dali::PanGesture *result = 0 ;
41329
41330   arg1 = (Dali::Gesture::State)jarg1;
41331   {
41332     try {
41333       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41334     } catch (std::out_of_range& e) {
41335       {
41336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41337       };
41338     } catch (std::exception& e) {
41339       {
41340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41341       };
41342     } catch (Dali::DaliException e) {
41343       {
41344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41345       };
41346     } catch (...) {
41347       {
41348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41349       };
41350     }
41351   }
41352
41353   jresult = (void *)result;
41354   return jresult;
41355 }
41356
41357
41358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41359   void * jresult ;
41360   Dali::PanGesture *arg1 = 0 ;
41361   Dali::PanGesture *result = 0 ;
41362
41363   arg1 = (Dali::PanGesture *)jarg1;
41364   if (!arg1) {
41365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41366     return 0;
41367   }
41368   {
41369     try {
41370       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41371     } catch (std::out_of_range& e) {
41372       {
41373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41374       };
41375     } catch (std::exception& e) {
41376       {
41377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41378       };
41379     } catch (Dali::DaliException e) {
41380       {
41381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41382       };
41383     } catch (...) {
41384       {
41385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41386       };
41387     }
41388   }
41389
41390   jresult = (void *)result;
41391   return jresult;
41392 }
41393
41394
41395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41396   void * jresult ;
41397   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41398   Dali::PanGesture *arg2 = 0 ;
41399   Dali::PanGesture *result = 0 ;
41400
41401   arg1 = (Dali::PanGesture *)jarg1;
41402   arg2 = (Dali::PanGesture *)jarg2;
41403   if (!arg2) {
41404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41405     return 0;
41406   }
41407   {
41408     try {
41409       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41410     } catch (std::out_of_range& e) {
41411       {
41412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41413       };
41414     } catch (std::exception& e) {
41415       {
41416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41417       };
41418     } catch (Dali::DaliException e) {
41419       {
41420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41421       };
41422     } catch (...) {
41423       {
41424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41425       };
41426     }
41427   }
41428
41429   jresult = (void *)result;
41430   return jresult;
41431 }
41432
41433
41434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41435   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41436
41437   arg1 = (Dali::PanGesture *)jarg1;
41438   {
41439     try {
41440       delete arg1;
41441     } catch (std::out_of_range& e) {
41442       {
41443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41444       };
41445     } catch (std::exception& e) {
41446       {
41447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41448       };
41449     } catch (Dali::DaliException e) {
41450       {
41451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41452       };
41453     } catch (...) {
41454       {
41455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41456       };
41457     }
41458   }
41459
41460 }
41461
41462
41463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41464   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41465   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41466
41467   arg1 = (Dali::PanGesture *)jarg1;
41468   arg2 = (Dali::Vector2 *)jarg2;
41469   if (arg1) (arg1)->velocity = *arg2;
41470 }
41471
41472
41473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41474   void * jresult ;
41475   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41476   Dali::Vector2 *result = 0 ;
41477
41478   arg1 = (Dali::PanGesture *)jarg1;
41479   result = (Dali::Vector2 *)& ((arg1)->velocity);
41480   jresult = (void *)result;
41481   return jresult;
41482 }
41483
41484
41485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41486   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41487   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41488
41489   arg1 = (Dali::PanGesture *)jarg1;
41490   arg2 = (Dali::Vector2 *)jarg2;
41491   if (arg1) (arg1)->displacement = *arg2;
41492 }
41493
41494
41495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41496   void * jresult ;
41497   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41498   Dali::Vector2 *result = 0 ;
41499
41500   arg1 = (Dali::PanGesture *)jarg1;
41501   result = (Dali::Vector2 *)& ((arg1)->displacement);
41502   jresult = (void *)result;
41503   return jresult;
41504 }
41505
41506
41507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41508   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41509   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41510
41511   arg1 = (Dali::PanGesture *)jarg1;
41512   arg2 = (Dali::Vector2 *)jarg2;
41513   if (arg1) (arg1)->position = *arg2;
41514 }
41515
41516
41517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41518   void * jresult ;
41519   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41520   Dali::Vector2 *result = 0 ;
41521
41522   arg1 = (Dali::PanGesture *)jarg1;
41523   result = (Dali::Vector2 *)& ((arg1)->position);
41524   jresult = (void *)result;
41525   return jresult;
41526 }
41527
41528
41529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41530   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41531   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41532
41533   arg1 = (Dali::PanGesture *)jarg1;
41534   arg2 = (Dali::Vector2 *)jarg2;
41535   if (arg1) (arg1)->screenVelocity = *arg2;
41536 }
41537
41538
41539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41540   void * jresult ;
41541   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41542   Dali::Vector2 *result = 0 ;
41543
41544   arg1 = (Dali::PanGesture *)jarg1;
41545   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41546   jresult = (void *)result;
41547   return jresult;
41548 }
41549
41550
41551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41552   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41553   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41554
41555   arg1 = (Dali::PanGesture *)jarg1;
41556   arg2 = (Dali::Vector2 *)jarg2;
41557   if (arg1) (arg1)->screenDisplacement = *arg2;
41558 }
41559
41560
41561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41562   void * jresult ;
41563   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41564   Dali::Vector2 *result = 0 ;
41565
41566   arg1 = (Dali::PanGesture *)jarg1;
41567   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41568   jresult = (void *)result;
41569   return jresult;
41570 }
41571
41572
41573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41574   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41575   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41576
41577   arg1 = (Dali::PanGesture *)jarg1;
41578   arg2 = (Dali::Vector2 *)jarg2;
41579   if (arg1) (arg1)->screenPosition = *arg2;
41580 }
41581
41582
41583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41584   void * jresult ;
41585   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41586   Dali::Vector2 *result = 0 ;
41587
41588   arg1 = (Dali::PanGesture *)jarg1;
41589   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41590   jresult = (void *)result;
41591   return jresult;
41592 }
41593
41594
41595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41596   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41597   unsigned int arg2 ;
41598
41599   arg1 = (Dali::PanGesture *)jarg1;
41600   arg2 = (unsigned int)jarg2;
41601   if (arg1) (arg1)->numberOfTouches = arg2;
41602 }
41603
41604
41605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41606   unsigned int jresult ;
41607   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41608   unsigned int result;
41609
41610   arg1 = (Dali::PanGesture *)jarg1;
41611   result = (unsigned int) ((arg1)->numberOfTouches);
41612   jresult = result;
41613   return jresult;
41614 }
41615
41616
41617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41618   float jresult ;
41619   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41620   float result;
41621
41622   arg1 = (Dali::PanGesture *)jarg1;
41623   {
41624     try {
41625       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41626     } catch (std::out_of_range& e) {
41627       {
41628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41629       };
41630     } catch (std::exception& e) {
41631       {
41632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41633       };
41634     } catch (Dali::DaliException e) {
41635       {
41636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41637       };
41638     } catch (...) {
41639       {
41640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41641       };
41642     }
41643   }
41644
41645   jresult = result;
41646   return jresult;
41647 }
41648
41649
41650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41651   float jresult ;
41652   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41653   float result;
41654
41655   arg1 = (Dali::PanGesture *)jarg1;
41656   {
41657     try {
41658       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41659     } catch (std::out_of_range& e) {
41660       {
41661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41662       };
41663     } catch (std::exception& e) {
41664       {
41665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41666       };
41667     } catch (Dali::DaliException e) {
41668       {
41669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41670       };
41671     } catch (...) {
41672       {
41673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41674       };
41675     }
41676   }
41677
41678   jresult = result;
41679   return jresult;
41680 }
41681
41682
41683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41684   float jresult ;
41685   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41686   float result;
41687
41688   arg1 = (Dali::PanGesture *)jarg1;
41689   {
41690     try {
41691       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41692     } catch (std::out_of_range& e) {
41693       {
41694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41695       };
41696     } catch (std::exception& e) {
41697       {
41698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41699       };
41700     } catch (Dali::DaliException e) {
41701       {
41702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41703       };
41704     } catch (...) {
41705       {
41706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41707       };
41708     }
41709   }
41710
41711   jresult = result;
41712   return jresult;
41713 }
41714
41715
41716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41717   float jresult ;
41718   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41719   float result;
41720
41721   arg1 = (Dali::PanGesture *)jarg1;
41722   {
41723     try {
41724       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41725     } catch (std::out_of_range& e) {
41726       {
41727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41728       };
41729     } catch (std::exception& e) {
41730       {
41731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41732       };
41733     } catch (Dali::DaliException e) {
41734       {
41735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41736       };
41737     } catch (...) {
41738       {
41739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41740       };
41741     }
41742   }
41743
41744   jresult = result;
41745   return jresult;
41746 }
41747
41748
41749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41750   void * jresult ;
41751   Dali::PinchGestureDetector *result = 0 ;
41752
41753   {
41754     try {
41755       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41756     } catch (std::out_of_range& e) {
41757       {
41758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41759       };
41760     } catch (std::exception& e) {
41761       {
41762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41763       };
41764     } catch (Dali::DaliException e) {
41765       {
41766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41767       };
41768     } catch (...) {
41769       {
41770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41771       };
41772     }
41773   }
41774
41775   jresult = (void *)result;
41776   return jresult;
41777 }
41778
41779
41780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41781   void * jresult ;
41782   Dali::PinchGestureDetector result;
41783
41784   {
41785     try {
41786       result = Dali::PinchGestureDetector::New();
41787     } catch (std::out_of_range& e) {
41788       {
41789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41790       };
41791     } catch (std::exception& e) {
41792       {
41793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41794       };
41795     } catch (Dali::DaliException e) {
41796       {
41797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41798       };
41799     } catch (...) {
41800       {
41801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41802       };
41803     }
41804   }
41805
41806   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41807   return jresult;
41808 }
41809
41810
41811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41812   void * jresult ;
41813   Dali::BaseHandle arg1 ;
41814   Dali::BaseHandle *argp1 ;
41815   Dali::PinchGestureDetector result;
41816
41817   argp1 = (Dali::BaseHandle *)jarg1;
41818   if (!argp1) {
41819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41820     return 0;
41821   }
41822   arg1 = *argp1;
41823   {
41824     try {
41825       result = Dali::PinchGestureDetector::DownCast(arg1);
41826     } catch (std::out_of_range& e) {
41827       {
41828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41829       };
41830     } catch (std::exception& e) {
41831       {
41832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41833       };
41834     } catch (Dali::DaliException e) {
41835       {
41836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41837       };
41838     } catch (...) {
41839       {
41840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41841       };
41842     }
41843   }
41844
41845   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41846   return jresult;
41847 }
41848
41849
41850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41851   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41852
41853   arg1 = (Dali::PinchGestureDetector *)jarg1;
41854   {
41855     try {
41856       delete arg1;
41857     } catch (std::out_of_range& e) {
41858       {
41859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41860       };
41861     } catch (std::exception& e) {
41862       {
41863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41864       };
41865     } catch (Dali::DaliException e) {
41866       {
41867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41868       };
41869     } catch (...) {
41870       {
41871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41872       };
41873     }
41874   }
41875
41876 }
41877
41878
41879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41880   void * jresult ;
41881   Dali::PinchGestureDetector *arg1 = 0 ;
41882   Dali::PinchGestureDetector *result = 0 ;
41883
41884   arg1 = (Dali::PinchGestureDetector *)jarg1;
41885   if (!arg1) {
41886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41887     return 0;
41888   }
41889   {
41890     try {
41891       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41892     } catch (std::out_of_range& e) {
41893       {
41894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41895       };
41896     } catch (std::exception& e) {
41897       {
41898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41899       };
41900     } catch (Dali::DaliException e) {
41901       {
41902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41903       };
41904     } catch (...) {
41905       {
41906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41907       };
41908     }
41909   }
41910
41911   jresult = (void *)result;
41912   return jresult;
41913 }
41914
41915
41916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41917   void * jresult ;
41918   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41919   Dali::PinchGestureDetector *arg2 = 0 ;
41920   Dali::PinchGestureDetector *result = 0 ;
41921
41922   arg1 = (Dali::PinchGestureDetector *)jarg1;
41923   arg2 = (Dali::PinchGestureDetector *)jarg2;
41924   if (!arg2) {
41925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41926     return 0;
41927   }
41928   {
41929     try {
41930       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41931     } catch (std::out_of_range& e) {
41932       {
41933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41934       };
41935     } catch (std::exception& e) {
41936       {
41937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41938       };
41939     } catch (Dali::DaliException e) {
41940       {
41941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41942       };
41943     } catch (...) {
41944       {
41945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41946       };
41947     }
41948   }
41949
41950   jresult = (void *)result;
41951   return jresult;
41952 }
41953
41954
41955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41956   void * jresult ;
41957   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41958   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41959
41960   arg1 = (Dali::PinchGestureDetector *)jarg1;
41961   {
41962     try {
41963       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41964     } catch (std::out_of_range& e) {
41965       {
41966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41967       };
41968     } catch (std::exception& e) {
41969       {
41970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41971       };
41972     } catch (Dali::DaliException e) {
41973       {
41974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41975       };
41976     } catch (...) {
41977       {
41978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41979       };
41980     }
41981   }
41982
41983   jresult = (void *)result;
41984   return jresult;
41985 }
41986
41987
41988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41989   void * jresult ;
41990   Dali::Gesture::State arg1 ;
41991   Dali::PinchGesture *result = 0 ;
41992
41993   arg1 = (Dali::Gesture::State)jarg1;
41994   {
41995     try {
41996       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41997     } catch (std::out_of_range& e) {
41998       {
41999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42000       };
42001     } catch (std::exception& e) {
42002       {
42003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42004       };
42005     } catch (Dali::DaliException e) {
42006       {
42007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42008       };
42009     } catch (...) {
42010       {
42011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42012       };
42013     }
42014   }
42015
42016   jresult = (void *)result;
42017   return jresult;
42018 }
42019
42020
42021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42022   void * jresult ;
42023   Dali::PinchGesture *arg1 = 0 ;
42024   Dali::PinchGesture *result = 0 ;
42025
42026   arg1 = (Dali::PinchGesture *)jarg1;
42027   if (!arg1) {
42028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42029     return 0;
42030   }
42031   {
42032     try {
42033       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42034     } catch (std::out_of_range& e) {
42035       {
42036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42037       };
42038     } catch (std::exception& e) {
42039       {
42040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42041       };
42042     } catch (Dali::DaliException e) {
42043       {
42044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42045       };
42046     } catch (...) {
42047       {
42048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42049       };
42050     }
42051   }
42052
42053   jresult = (void *)result;
42054   return jresult;
42055 }
42056
42057
42058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42059   void * jresult ;
42060   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42061   Dali::PinchGesture *arg2 = 0 ;
42062   Dali::PinchGesture *result = 0 ;
42063
42064   arg1 = (Dali::PinchGesture *)jarg1;
42065   arg2 = (Dali::PinchGesture *)jarg2;
42066   if (!arg2) {
42067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42068     return 0;
42069   }
42070   {
42071     try {
42072       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42073     } catch (std::out_of_range& e) {
42074       {
42075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42076       };
42077     } catch (std::exception& e) {
42078       {
42079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42080       };
42081     } catch (Dali::DaliException e) {
42082       {
42083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42084       };
42085     } catch (...) {
42086       {
42087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42088       };
42089     }
42090   }
42091
42092   jresult = (void *)result;
42093   return jresult;
42094 }
42095
42096
42097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42098   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42099
42100   arg1 = (Dali::PinchGesture *)jarg1;
42101   {
42102     try {
42103       delete arg1;
42104     } catch (std::out_of_range& e) {
42105       {
42106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42107       };
42108     } catch (std::exception& e) {
42109       {
42110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42111       };
42112     } catch (Dali::DaliException e) {
42113       {
42114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42115       };
42116     } catch (...) {
42117       {
42118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42119       };
42120     }
42121   }
42122
42123 }
42124
42125
42126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42127   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42128   float arg2 ;
42129
42130   arg1 = (Dali::PinchGesture *)jarg1;
42131   arg2 = (float)jarg2;
42132   if (arg1) (arg1)->scale = arg2;
42133 }
42134
42135
42136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42137   float jresult ;
42138   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42139   float result;
42140
42141   arg1 = (Dali::PinchGesture *)jarg1;
42142   result = (float) ((arg1)->scale);
42143   jresult = result;
42144   return jresult;
42145 }
42146
42147
42148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42149   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42150   float arg2 ;
42151
42152   arg1 = (Dali::PinchGesture *)jarg1;
42153   arg2 = (float)jarg2;
42154   if (arg1) (arg1)->speed = arg2;
42155 }
42156
42157
42158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42159   float jresult ;
42160   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42161   float result;
42162
42163   arg1 = (Dali::PinchGesture *)jarg1;
42164   result = (float) ((arg1)->speed);
42165   jresult = result;
42166   return jresult;
42167 }
42168
42169
42170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42171   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42172   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42173
42174   arg1 = (Dali::PinchGesture *)jarg1;
42175   arg2 = (Dali::Vector2 *)jarg2;
42176   if (arg1) (arg1)->screenCenterPoint = *arg2;
42177 }
42178
42179
42180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42181   void * jresult ;
42182   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42183   Dali::Vector2 *result = 0 ;
42184
42185   arg1 = (Dali::PinchGesture *)jarg1;
42186   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42187   jresult = (void *)result;
42188   return jresult;
42189 }
42190
42191
42192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42193   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42194   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42195
42196   arg1 = (Dali::PinchGesture *)jarg1;
42197   arg2 = (Dali::Vector2 *)jarg2;
42198   if (arg1) (arg1)->localCenterPoint = *arg2;
42199 }
42200
42201
42202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42203   void * jresult ;
42204   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42205   Dali::Vector2 *result = 0 ;
42206
42207   arg1 = (Dali::PinchGesture *)jarg1;
42208   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42209   jresult = (void *)result;
42210   return jresult;
42211 }
42212
42213
42214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42215   void * jresult ;
42216   Dali::TapGestureDetector *result = 0 ;
42217
42218   {
42219     try {
42220       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42221     } catch (std::out_of_range& e) {
42222       {
42223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42224       };
42225     } catch (std::exception& e) {
42226       {
42227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42228       };
42229     } catch (Dali::DaliException e) {
42230       {
42231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42232       };
42233     } catch (...) {
42234       {
42235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42236       };
42237     }
42238   }
42239
42240   jresult = (void *)result;
42241   return jresult;
42242 }
42243
42244
42245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42246   void * jresult ;
42247   Dali::TapGestureDetector result;
42248
42249   {
42250     try {
42251       result = Dali::TapGestureDetector::New();
42252     } catch (std::out_of_range& e) {
42253       {
42254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42255       };
42256     } catch (std::exception& e) {
42257       {
42258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42259       };
42260     } catch (Dali::DaliException e) {
42261       {
42262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42263       };
42264     } catch (...) {
42265       {
42266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42267       };
42268     }
42269   }
42270
42271   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42272   return jresult;
42273 }
42274
42275
42276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42277   void * jresult ;
42278   unsigned int arg1 ;
42279   Dali::TapGestureDetector result;
42280
42281   arg1 = (unsigned int)jarg1;
42282   {
42283     try {
42284       result = Dali::TapGestureDetector::New(arg1);
42285     } catch (std::out_of_range& e) {
42286       {
42287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42288       };
42289     } catch (std::exception& e) {
42290       {
42291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42292       };
42293     } catch (Dali::DaliException e) {
42294       {
42295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42296       };
42297     } catch (...) {
42298       {
42299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42300       };
42301     }
42302   }
42303
42304   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42305   return jresult;
42306 }
42307
42308
42309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42310   void * jresult ;
42311   Dali::BaseHandle arg1 ;
42312   Dali::BaseHandle *argp1 ;
42313   Dali::TapGestureDetector result;
42314
42315   argp1 = (Dali::BaseHandle *)jarg1;
42316   if (!argp1) {
42317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42318     return 0;
42319   }
42320   arg1 = *argp1;
42321   {
42322     try {
42323       result = Dali::TapGestureDetector::DownCast(arg1);
42324     } catch (std::out_of_range& e) {
42325       {
42326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42327       };
42328     } catch (std::exception& e) {
42329       {
42330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42331       };
42332     } catch (Dali::DaliException e) {
42333       {
42334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42335       };
42336     } catch (...) {
42337       {
42338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42339       };
42340     }
42341   }
42342
42343   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42344   return jresult;
42345 }
42346
42347
42348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42349   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42350
42351   arg1 = (Dali::TapGestureDetector *)jarg1;
42352   {
42353     try {
42354       delete arg1;
42355     } catch (std::out_of_range& e) {
42356       {
42357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42358       };
42359     } catch (std::exception& e) {
42360       {
42361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42362       };
42363     } catch (Dali::DaliException e) {
42364       {
42365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42366       };
42367     } catch (...) {
42368       {
42369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42370       };
42371     }
42372   }
42373
42374 }
42375
42376
42377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42378   void * jresult ;
42379   Dali::TapGestureDetector *arg1 = 0 ;
42380   Dali::TapGestureDetector *result = 0 ;
42381
42382   arg1 = (Dali::TapGestureDetector *)jarg1;
42383   if (!arg1) {
42384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42385     return 0;
42386   }
42387   {
42388     try {
42389       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42390     } catch (std::out_of_range& e) {
42391       {
42392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42393       };
42394     } catch (std::exception& e) {
42395       {
42396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42397       };
42398     } catch (Dali::DaliException e) {
42399       {
42400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42401       };
42402     } catch (...) {
42403       {
42404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42405       };
42406     }
42407   }
42408
42409   jresult = (void *)result;
42410   return jresult;
42411 }
42412
42413
42414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42415   void * jresult ;
42416   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42417   Dali::TapGestureDetector *arg2 = 0 ;
42418   Dali::TapGestureDetector *result = 0 ;
42419
42420   arg1 = (Dali::TapGestureDetector *)jarg1;
42421   arg2 = (Dali::TapGestureDetector *)jarg2;
42422   if (!arg2) {
42423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42424     return 0;
42425   }
42426   {
42427     try {
42428       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42429     } catch (std::out_of_range& e) {
42430       {
42431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42432       };
42433     } catch (std::exception& e) {
42434       {
42435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42436       };
42437     } catch (Dali::DaliException e) {
42438       {
42439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42440       };
42441     } catch (...) {
42442       {
42443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42444       };
42445     }
42446   }
42447
42448   jresult = (void *)result;
42449   return jresult;
42450 }
42451
42452
42453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42454   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42455   unsigned int arg2 ;
42456
42457   arg1 = (Dali::TapGestureDetector *)jarg1;
42458   arg2 = (unsigned int)jarg2;
42459   {
42460     try {
42461       (arg1)->SetMinimumTapsRequired(arg2);
42462     } catch (std::out_of_range& e) {
42463       {
42464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42465       };
42466     } catch (std::exception& e) {
42467       {
42468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42469       };
42470     } catch (Dali::DaliException e) {
42471       {
42472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42473       };
42474     } catch (...) {
42475       {
42476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42477       };
42478     }
42479   }
42480
42481 }
42482
42483
42484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42485   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42486   unsigned int arg2 ;
42487
42488   arg1 = (Dali::TapGestureDetector *)jarg1;
42489   arg2 = (unsigned int)jarg2;
42490   {
42491     try {
42492       (arg1)->SetMaximumTapsRequired(arg2);
42493     } catch (std::out_of_range& e) {
42494       {
42495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42496       };
42497     } catch (std::exception& e) {
42498       {
42499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42500       };
42501     } catch (Dali::DaliException e) {
42502       {
42503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42504       };
42505     } catch (...) {
42506       {
42507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42508       };
42509     }
42510   }
42511
42512 }
42513
42514
42515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42516   unsigned int jresult ;
42517   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42518   unsigned int result;
42519
42520   arg1 = (Dali::TapGestureDetector *)jarg1;
42521   {
42522     try {
42523       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42524     } catch (std::out_of_range& e) {
42525       {
42526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42527       };
42528     } catch (std::exception& e) {
42529       {
42530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42531       };
42532     } catch (Dali::DaliException e) {
42533       {
42534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42535       };
42536     } catch (...) {
42537       {
42538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42539       };
42540     }
42541   }
42542
42543   jresult = result;
42544   return jresult;
42545 }
42546
42547
42548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42549   unsigned int jresult ;
42550   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42551   unsigned int result;
42552
42553   arg1 = (Dali::TapGestureDetector *)jarg1;
42554   {
42555     try {
42556       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42557     } catch (std::out_of_range& e) {
42558       {
42559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42560       };
42561     } catch (std::exception& e) {
42562       {
42563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42564       };
42565     } catch (Dali::DaliException e) {
42566       {
42567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42568       };
42569     } catch (...) {
42570       {
42571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42572       };
42573     }
42574   }
42575
42576   jresult = result;
42577   return jresult;
42578 }
42579
42580
42581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42582   void * jresult ;
42583   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42584   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42585
42586   arg1 = (Dali::TapGestureDetector *)jarg1;
42587   {
42588     try {
42589       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42590     } catch (std::out_of_range& e) {
42591       {
42592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42593       };
42594     } catch (std::exception& e) {
42595       {
42596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42597       };
42598     } catch (Dali::DaliException e) {
42599       {
42600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42601       };
42602     } catch (...) {
42603       {
42604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42605       };
42606     }
42607   }
42608
42609   jresult = (void *)result;
42610   return jresult;
42611 }
42612
42613
42614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42615   void * jresult ;
42616   Dali::TapGesture *result = 0 ;
42617
42618   {
42619     try {
42620       result = (Dali::TapGesture *)new Dali::TapGesture();
42621     } catch (std::out_of_range& e) {
42622       {
42623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42624       };
42625     } catch (std::exception& e) {
42626       {
42627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42628       };
42629     } catch (Dali::DaliException e) {
42630       {
42631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42632       };
42633     } catch (...) {
42634       {
42635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42636       };
42637     }
42638   }
42639
42640   jresult = (void *)result;
42641   return jresult;
42642 }
42643
42644
42645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42646   void * jresult ;
42647   Dali::TapGesture *arg1 = 0 ;
42648   Dali::TapGesture *result = 0 ;
42649
42650   arg1 = (Dali::TapGesture *)jarg1;
42651   if (!arg1) {
42652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42653     return 0;
42654   }
42655   {
42656     try {
42657       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42658     } catch (std::out_of_range& e) {
42659       {
42660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42661       };
42662     } catch (std::exception& e) {
42663       {
42664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42665       };
42666     } catch (Dali::DaliException e) {
42667       {
42668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42669       };
42670     } catch (...) {
42671       {
42672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42673       };
42674     }
42675   }
42676
42677   jresult = (void *)result;
42678   return jresult;
42679 }
42680
42681
42682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42683   void * jresult ;
42684   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42685   Dali::TapGesture *arg2 = 0 ;
42686   Dali::TapGesture *result = 0 ;
42687
42688   arg1 = (Dali::TapGesture *)jarg1;
42689   arg2 = (Dali::TapGesture *)jarg2;
42690   if (!arg2) {
42691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42692     return 0;
42693   }
42694   {
42695     try {
42696       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42697     } catch (std::out_of_range& e) {
42698       {
42699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42700       };
42701     } catch (std::exception& e) {
42702       {
42703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42704       };
42705     } catch (Dali::DaliException e) {
42706       {
42707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42708       };
42709     } catch (...) {
42710       {
42711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42712       };
42713     }
42714   }
42715
42716   jresult = (void *)result;
42717   return jresult;
42718 }
42719
42720
42721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42722   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42723
42724   arg1 = (Dali::TapGesture *)jarg1;
42725   {
42726     try {
42727       delete arg1;
42728     } catch (std::out_of_range& e) {
42729       {
42730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42731       };
42732     } catch (std::exception& e) {
42733       {
42734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42735       };
42736     } catch (Dali::DaliException e) {
42737       {
42738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42739       };
42740     } catch (...) {
42741       {
42742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42743       };
42744     }
42745   }
42746
42747 }
42748
42749
42750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42751   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42752   unsigned int arg2 ;
42753
42754   arg1 = (Dali::TapGesture *)jarg1;
42755   arg2 = (unsigned int)jarg2;
42756   if (arg1) (arg1)->numberOfTaps = arg2;
42757 }
42758
42759
42760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42761   unsigned int jresult ;
42762   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42763   unsigned int result;
42764
42765   arg1 = (Dali::TapGesture *)jarg1;
42766   result = (unsigned int) ((arg1)->numberOfTaps);
42767   jresult = result;
42768   return jresult;
42769 }
42770
42771
42772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42773   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42774   unsigned int arg2 ;
42775
42776   arg1 = (Dali::TapGesture *)jarg1;
42777   arg2 = (unsigned int)jarg2;
42778   if (arg1) (arg1)->numberOfTouches = arg2;
42779 }
42780
42781
42782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42783   unsigned int jresult ;
42784   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42785   unsigned int result;
42786
42787   arg1 = (Dali::TapGesture *)jarg1;
42788   result = (unsigned int) ((arg1)->numberOfTouches);
42789   jresult = result;
42790   return jresult;
42791 }
42792
42793
42794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42795   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42796   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42797
42798   arg1 = (Dali::TapGesture *)jarg1;
42799   arg2 = (Dali::Vector2 *)jarg2;
42800   if (arg1) (arg1)->screenPoint = *arg2;
42801 }
42802
42803
42804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42805   void * jresult ;
42806   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42807   Dali::Vector2 *result = 0 ;
42808
42809   arg1 = (Dali::TapGesture *)jarg1;
42810   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42811   jresult = (void *)result;
42812   return jresult;
42813 }
42814
42815
42816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42817   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42818   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42819
42820   arg1 = (Dali::TapGesture *)jarg1;
42821   arg2 = (Dali::Vector2 *)jarg2;
42822   if (arg1) (arg1)->localPoint = *arg2;
42823 }
42824
42825
42826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42827   void * jresult ;
42828   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42829   Dali::Vector2 *result = 0 ;
42830
42831   arg1 = (Dali::TapGesture *)jarg1;
42832   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42833   jresult = (void *)result;
42834   return jresult;
42835 }
42836
42837
42838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42839   void * jresult ;
42840   Dali::AlphaFunction *result = 0 ;
42841
42842   {
42843     try {
42844       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42845     } catch (std::out_of_range& e) {
42846       {
42847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42848       };
42849     } catch (std::exception& e) {
42850       {
42851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42852       };
42853     } catch (Dali::DaliException e) {
42854       {
42855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42856       };
42857     } catch (...) {
42858       {
42859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42860       };
42861     }
42862   }
42863
42864   jresult = (void *)result;
42865   return jresult;
42866 }
42867
42868
42869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42870   void * jresult ;
42871   Dali::AlphaFunction::BuiltinFunction arg1 ;
42872   Dali::AlphaFunction *result = 0 ;
42873
42874   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42875   {
42876     try {
42877       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42878     } catch (std::out_of_range& e) {
42879       {
42880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42881       };
42882     } catch (std::exception& e) {
42883       {
42884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42885       };
42886     } catch (Dali::DaliException e) {
42887       {
42888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42889       };
42890     } catch (...) {
42891       {
42892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42893       };
42894     }
42895   }
42896
42897   jresult = (void *)result;
42898   return jresult;
42899 }
42900
42901
42902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42903   void * jresult ;
42904   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42905   Dali::AlphaFunction *result = 0 ;
42906
42907   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42908   {
42909     try {
42910       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42911     } catch (std::out_of_range& e) {
42912       {
42913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42914       };
42915     } catch (std::exception& e) {
42916       {
42917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42918       };
42919     } catch (Dali::DaliException e) {
42920       {
42921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42922       };
42923     } catch (...) {
42924       {
42925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42926       };
42927     }
42928   }
42929
42930   jresult = (void *)result;
42931   return jresult;
42932 }
42933
42934
42935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42936   void * jresult ;
42937   Dali::Vector2 *arg1 = 0 ;
42938   Dali::Vector2 *arg2 = 0 ;
42939   Dali::AlphaFunction *result = 0 ;
42940
42941   arg1 = (Dali::Vector2 *)jarg1;
42942   if (!arg1) {
42943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42944     return 0;
42945   }
42946   arg2 = (Dali::Vector2 *)jarg2;
42947   if (!arg2) {
42948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42949     return 0;
42950   }
42951   {
42952     try {
42953       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42954     } catch (std::out_of_range& e) {
42955       {
42956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42957       };
42958     } catch (std::exception& e) {
42959       {
42960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42961       };
42962     } catch (Dali::DaliException e) {
42963       {
42964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42965       };
42966     } catch (...) {
42967       {
42968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42969       };
42970     }
42971   }
42972
42973   jresult = (void *)result;
42974   return jresult;
42975 }
42976
42977
42978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42979   void * jresult ;
42980   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42981   Dali::Vector4 result;
42982
42983   arg1 = (Dali::AlphaFunction *)jarg1;
42984   {
42985     try {
42986       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42987     } catch (std::out_of_range& e) {
42988       {
42989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42990       };
42991     } catch (std::exception& e) {
42992       {
42993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42994       };
42995     } catch (Dali::DaliException e) {
42996       {
42997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42998       };
42999     } catch (...) {
43000       {
43001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43002       };
43003     }
43004   }
43005
43006   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43007   return jresult;
43008 }
43009
43010
43011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43012   void * jresult ;
43013   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43014   Dali::AlphaFunctionPrototype result;
43015
43016   arg1 = (Dali::AlphaFunction *)jarg1;
43017   {
43018     try {
43019       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43020     } catch (std::out_of_range& e) {
43021       {
43022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43023       };
43024     } catch (std::exception& e) {
43025       {
43026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43027       };
43028     } catch (Dali::DaliException e) {
43029       {
43030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43031       };
43032     } catch (...) {
43033       {
43034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43035       };
43036     }
43037   }
43038
43039   jresult = (void *)result;
43040   return jresult;
43041 }
43042
43043
43044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43045   int jresult ;
43046   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43047   Dali::AlphaFunction::BuiltinFunction result;
43048
43049   arg1 = (Dali::AlphaFunction *)jarg1;
43050   {
43051     try {
43052       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43053     } catch (std::out_of_range& e) {
43054       {
43055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43056       };
43057     } catch (std::exception& e) {
43058       {
43059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43060       };
43061     } catch (Dali::DaliException e) {
43062       {
43063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43064       };
43065     } catch (...) {
43066       {
43067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43068       };
43069     }
43070   }
43071
43072   jresult = (int)result;
43073   return jresult;
43074 }
43075
43076
43077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43078   int jresult ;
43079   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43080   Dali::AlphaFunction::Mode result;
43081
43082   arg1 = (Dali::AlphaFunction *)jarg1;
43083   {
43084     try {
43085       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43086     } catch (std::out_of_range& e) {
43087       {
43088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43089       };
43090     } catch (std::exception& e) {
43091       {
43092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43093       };
43094     } catch (Dali::DaliException e) {
43095       {
43096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43097       };
43098     } catch (...) {
43099       {
43100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43101       };
43102     }
43103   }
43104
43105   jresult = (int)result;
43106   return jresult;
43107 }
43108
43109
43110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43111   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43112
43113   arg1 = (Dali::AlphaFunction *)jarg1;
43114   {
43115     try {
43116       delete arg1;
43117     } catch (std::out_of_range& e) {
43118       {
43119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43120       };
43121     } catch (std::exception& e) {
43122       {
43123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43124       };
43125     } catch (Dali::DaliException e) {
43126       {
43127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43128       };
43129     } catch (...) {
43130       {
43131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43132       };
43133     }
43134   }
43135
43136 }
43137
43138
43139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43140   void * jresult ;
43141   Dali::KeyFrames result;
43142
43143   {
43144     try {
43145       result = Dali::KeyFrames::New();
43146     } catch (std::out_of_range& e) {
43147       {
43148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43149       };
43150     } catch (std::exception& e) {
43151       {
43152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43153       };
43154     } catch (Dali::DaliException e) {
43155       {
43156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43157       };
43158     } catch (...) {
43159       {
43160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43161       };
43162     }
43163   }
43164
43165   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43166   return jresult;
43167 }
43168
43169
43170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43171   void * jresult ;
43172   Dali::BaseHandle arg1 ;
43173   Dali::BaseHandle *argp1 ;
43174   Dali::KeyFrames result;
43175
43176   argp1 = (Dali::BaseHandle *)jarg1;
43177   if (!argp1) {
43178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43179     return 0;
43180   }
43181   arg1 = *argp1;
43182   {
43183     try {
43184       result = Dali::KeyFrames::DownCast(arg1);
43185     } catch (std::out_of_range& e) {
43186       {
43187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43188       };
43189     } catch (std::exception& e) {
43190       {
43191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43192       };
43193     } catch (Dali::DaliException e) {
43194       {
43195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43196       };
43197     } catch (...) {
43198       {
43199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43200       };
43201     }
43202   }
43203
43204   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43205   return jresult;
43206 }
43207
43208
43209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43210   void * jresult ;
43211   Dali::KeyFrames *result = 0 ;
43212
43213   {
43214     try {
43215       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43216     } catch (std::out_of_range& e) {
43217       {
43218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43219       };
43220     } catch (std::exception& e) {
43221       {
43222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43223       };
43224     } catch (Dali::DaliException e) {
43225       {
43226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43227       };
43228     } catch (...) {
43229       {
43230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43231       };
43232     }
43233   }
43234
43235   jresult = (void *)result;
43236   return jresult;
43237 }
43238
43239
43240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43241   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43242
43243   arg1 = (Dali::KeyFrames *)jarg1;
43244   {
43245     try {
43246       delete arg1;
43247     } catch (std::out_of_range& e) {
43248       {
43249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43250       };
43251     } catch (std::exception& e) {
43252       {
43253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43254       };
43255     } catch (Dali::DaliException e) {
43256       {
43257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43258       };
43259     } catch (...) {
43260       {
43261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43262       };
43263     }
43264   }
43265
43266 }
43267
43268
43269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43270   void * jresult ;
43271   Dali::KeyFrames *arg1 = 0 ;
43272   Dali::KeyFrames *result = 0 ;
43273
43274   arg1 = (Dali::KeyFrames *)jarg1;
43275   if (!arg1) {
43276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43277     return 0;
43278   }
43279   {
43280     try {
43281       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43282     } catch (std::out_of_range& e) {
43283       {
43284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43285       };
43286     } catch (std::exception& e) {
43287       {
43288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43289       };
43290     } catch (Dali::DaliException e) {
43291       {
43292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43293       };
43294     } catch (...) {
43295       {
43296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43297       };
43298     }
43299   }
43300
43301   jresult = (void *)result;
43302   return jresult;
43303 }
43304
43305
43306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43307   void * jresult ;
43308   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43309   Dali::KeyFrames *arg2 = 0 ;
43310   Dali::KeyFrames *result = 0 ;
43311
43312   arg1 = (Dali::KeyFrames *)jarg1;
43313   arg2 = (Dali::KeyFrames *)jarg2;
43314   if (!arg2) {
43315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43316     return 0;
43317   }
43318   {
43319     try {
43320       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43321     } catch (std::out_of_range& e) {
43322       {
43323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43324       };
43325     } catch (std::exception& e) {
43326       {
43327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43328       };
43329     } catch (Dali::DaliException e) {
43330       {
43331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43332       };
43333     } catch (...) {
43334       {
43335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43336       };
43337     }
43338   }
43339
43340   jresult = (void *)result;
43341   return jresult;
43342 }
43343
43344
43345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43346   int jresult ;
43347   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43348   Dali::Property::Type result;
43349
43350   arg1 = (Dali::KeyFrames *)jarg1;
43351   {
43352     try {
43353       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43354     } catch (std::out_of_range& e) {
43355       {
43356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43357       };
43358     } catch (std::exception& e) {
43359       {
43360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43361       };
43362     } catch (Dali::DaliException e) {
43363       {
43364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43365       };
43366     } catch (...) {
43367       {
43368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43369       };
43370     }
43371   }
43372
43373   jresult = (int)result;
43374   return jresult;
43375 }
43376
43377
43378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43379   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43380   float arg2 ;
43381   Dali::Property::Value arg3 ;
43382   Dali::Property::Value *argp3 ;
43383
43384   arg1 = (Dali::KeyFrames *)jarg1;
43385   arg2 = (float)jarg2;
43386   argp3 = (Dali::Property::Value *)jarg3;
43387   if (!argp3) {
43388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43389     return ;
43390   }
43391   arg3 = *argp3;
43392   {
43393     try {
43394       (arg1)->Add(arg2,arg3);
43395     } catch (std::out_of_range& e) {
43396       {
43397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43398       };
43399     } catch (std::exception& e) {
43400       {
43401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43402       };
43403     } catch (Dali::DaliException e) {
43404       {
43405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43406       };
43407     } catch (...) {
43408       {
43409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43410       };
43411     }
43412   }
43413
43414 }
43415
43416
43417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43418   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43419   float arg2 ;
43420   Dali::Property::Value arg3 ;
43421   Dali::AlphaFunction arg4 ;
43422   Dali::Property::Value *argp3 ;
43423   Dali::AlphaFunction *argp4 ;
43424
43425   arg1 = (Dali::KeyFrames *)jarg1;
43426   arg2 = (float)jarg2;
43427   argp3 = (Dali::Property::Value *)jarg3;
43428   if (!argp3) {
43429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43430     return ;
43431   }
43432   arg3 = *argp3;
43433   argp4 = (Dali::AlphaFunction *)jarg4;
43434   if (!argp4) {
43435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43436     return ;
43437   }
43438   arg4 = *argp4;
43439   {
43440     try {
43441       (arg1)->Add(arg2,arg3,arg4);
43442     } catch (std::out_of_range& e) {
43443       {
43444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43445       };
43446     } catch (std::exception& e) {
43447       {
43448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43449       };
43450     } catch (Dali::DaliException e) {
43451       {
43452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43453       };
43454     } catch (...) {
43455       {
43456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43457       };
43458     }
43459   }
43460
43461 }
43462
43463
43464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43465   int jresult ;
43466   int result;
43467
43468   result = (int)Dali::Path::Property::POINTS;
43469   jresult = (int)result;
43470   return jresult;
43471 }
43472
43473
43474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43475   int jresult ;
43476   int result;
43477
43478   result = (int)Dali::Path::Property::CONTROL_POINTS;
43479   jresult = (int)result;
43480   return jresult;
43481 }
43482
43483
43484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43485   void * jresult ;
43486   Dali::Path::Property *result = 0 ;
43487
43488   {
43489     try {
43490       result = (Dali::Path::Property *)new Dali::Path::Property();
43491     } catch (std::out_of_range& e) {
43492       {
43493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43494       };
43495     } catch (std::exception& e) {
43496       {
43497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43498       };
43499     } catch (Dali::DaliException e) {
43500       {
43501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43502       };
43503     } catch (...) {
43504       {
43505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43506       };
43507     }
43508   }
43509
43510   jresult = (void *)result;
43511   return jresult;
43512 }
43513
43514
43515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43516   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43517
43518   arg1 = (Dali::Path::Property *)jarg1;
43519   {
43520     try {
43521       delete arg1;
43522     } catch (std::out_of_range& e) {
43523       {
43524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43525       };
43526     } catch (std::exception& e) {
43527       {
43528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43529       };
43530     } catch (Dali::DaliException e) {
43531       {
43532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43533       };
43534     } catch (...) {
43535       {
43536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43537       };
43538     }
43539   }
43540
43541 }
43542
43543
43544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43545   void * jresult ;
43546   Dali::Path result;
43547
43548   {
43549     try {
43550       result = Dali::Path::New();
43551     } catch (std::out_of_range& e) {
43552       {
43553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43554       };
43555     } catch (std::exception& e) {
43556       {
43557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43558       };
43559     } catch (Dali::DaliException e) {
43560       {
43561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43562       };
43563     } catch (...) {
43564       {
43565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43566       };
43567     }
43568   }
43569
43570   jresult = new Dali::Path((const Dali::Path &)result);
43571   return jresult;
43572 }
43573
43574
43575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43576   void * jresult ;
43577   Dali::BaseHandle arg1 ;
43578   Dali::BaseHandle *argp1 ;
43579   Dali::Path result;
43580
43581   argp1 = (Dali::BaseHandle *)jarg1;
43582   if (!argp1) {
43583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43584     return 0;
43585   }
43586   arg1 = *argp1;
43587   {
43588     try {
43589       result = Dali::Path::DownCast(arg1);
43590     } catch (std::out_of_range& e) {
43591       {
43592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43593       };
43594     } catch (std::exception& e) {
43595       {
43596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43597       };
43598     } catch (Dali::DaliException e) {
43599       {
43600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43601       };
43602     } catch (...) {
43603       {
43604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43605       };
43606     }
43607   }
43608
43609   jresult = new Dali::Path((const Dali::Path &)result);
43610   return jresult;
43611 }
43612
43613
43614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43615   void * jresult ;
43616   Dali::Path *result = 0 ;
43617
43618   {
43619     try {
43620       result = (Dali::Path *)new Dali::Path();
43621     } catch (std::out_of_range& e) {
43622       {
43623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43624       };
43625     } catch (std::exception& e) {
43626       {
43627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43628       };
43629     } catch (Dali::DaliException e) {
43630       {
43631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43632       };
43633     } catch (...) {
43634       {
43635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43636       };
43637     }
43638   }
43639
43640   jresult = (void *)result;
43641   return jresult;
43642 }
43643
43644
43645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43646   Dali::Path *arg1 = (Dali::Path *) 0 ;
43647
43648   arg1 = (Dali::Path *)jarg1;
43649   {
43650     try {
43651       delete arg1;
43652     } catch (std::out_of_range& e) {
43653       {
43654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43655       };
43656     } catch (std::exception& e) {
43657       {
43658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43659       };
43660     } catch (Dali::DaliException e) {
43661       {
43662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43663       };
43664     } catch (...) {
43665       {
43666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43667       };
43668     }
43669   }
43670
43671 }
43672
43673
43674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43675   void * jresult ;
43676   Dali::Path *arg1 = 0 ;
43677   Dali::Path *result = 0 ;
43678
43679   arg1 = (Dali::Path *)jarg1;
43680   if (!arg1) {
43681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43682     return 0;
43683   }
43684   {
43685     try {
43686       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43687     } catch (std::out_of_range& e) {
43688       {
43689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43690       };
43691     } catch (std::exception& e) {
43692       {
43693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43694       };
43695     } catch (Dali::DaliException e) {
43696       {
43697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43698       };
43699     } catch (...) {
43700       {
43701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43702       };
43703     }
43704   }
43705
43706   jresult = (void *)result;
43707   return jresult;
43708 }
43709
43710
43711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43712   void * jresult ;
43713   Dali::Path *arg1 = (Dali::Path *) 0 ;
43714   Dali::Path *arg2 = 0 ;
43715   Dali::Path *result = 0 ;
43716
43717   arg1 = (Dali::Path *)jarg1;
43718   arg2 = (Dali::Path *)jarg2;
43719   if (!arg2) {
43720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43721     return 0;
43722   }
43723   {
43724     try {
43725       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43726     } catch (std::out_of_range& e) {
43727       {
43728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43729       };
43730     } catch (std::exception& e) {
43731       {
43732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43733       };
43734     } catch (Dali::DaliException e) {
43735       {
43736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43737       };
43738     } catch (...) {
43739       {
43740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43741       };
43742     }
43743   }
43744
43745   jresult = (void *)result;
43746   return jresult;
43747 }
43748
43749
43750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43751   Dali::Path *arg1 = (Dali::Path *) 0 ;
43752   Dali::Vector3 *arg2 = 0 ;
43753
43754   arg1 = (Dali::Path *)jarg1;
43755   arg2 = (Dali::Vector3 *)jarg2;
43756   if (!arg2) {
43757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43758     return ;
43759   }
43760   {
43761     try {
43762       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43763     } catch (std::out_of_range& e) {
43764       {
43765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43766       };
43767     } catch (std::exception& e) {
43768       {
43769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43770       };
43771     } catch (Dali::DaliException e) {
43772       {
43773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43774       };
43775     } catch (...) {
43776       {
43777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43778       };
43779     }
43780   }
43781
43782 }
43783
43784
43785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43786   Dali::Path *arg1 = (Dali::Path *) 0 ;
43787   Dali::Vector3 *arg2 = 0 ;
43788
43789   arg1 = (Dali::Path *)jarg1;
43790   arg2 = (Dali::Vector3 *)jarg2;
43791   if (!arg2) {
43792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43793     return ;
43794   }
43795   {
43796     try {
43797       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43798     } catch (std::out_of_range& e) {
43799       {
43800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43801       };
43802     } catch (std::exception& e) {
43803       {
43804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43805       };
43806     } catch (Dali::DaliException e) {
43807       {
43808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43809       };
43810     } catch (...) {
43811       {
43812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43813       };
43814     }
43815   }
43816
43817 }
43818
43819
43820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43821   Dali::Path *arg1 = (Dali::Path *) 0 ;
43822   float arg2 ;
43823
43824   arg1 = (Dali::Path *)jarg1;
43825   arg2 = (float)jarg2;
43826   {
43827     try {
43828       (arg1)->GenerateControlPoints(arg2);
43829     } catch (std::out_of_range& e) {
43830       {
43831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43832       };
43833     } catch (std::exception& e) {
43834       {
43835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43836       };
43837     } catch (Dali::DaliException e) {
43838       {
43839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43840       };
43841     } catch (...) {
43842       {
43843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43844       };
43845     }
43846   }
43847
43848 }
43849
43850
43851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43852   Dali::Path *arg1 = (Dali::Path *) 0 ;
43853   float arg2 ;
43854   Dali::Vector3 *arg3 = 0 ;
43855   Dali::Vector3 *arg4 = 0 ;
43856
43857   arg1 = (Dali::Path *)jarg1;
43858   arg2 = (float)jarg2;
43859   arg3 = (Dali::Vector3 *)jarg3;
43860   if (!arg3) {
43861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43862     return ;
43863   }
43864   arg4 = (Dali::Vector3 *)jarg4;
43865   if (!arg4) {
43866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43867     return ;
43868   }
43869   {
43870     try {
43871       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43872     } catch (std::out_of_range& e) {
43873       {
43874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43875       };
43876     } catch (std::exception& e) {
43877       {
43878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43879       };
43880     } catch (Dali::DaliException e) {
43881       {
43882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43883       };
43884     } catch (...) {
43885       {
43886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43887       };
43888     }
43889   }
43890
43891 }
43892
43893
43894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43895   void * jresult ;
43896   Dali::Path *arg1 = (Dali::Path *) 0 ;
43897   size_t arg2 ;
43898   Dali::Vector3 *result = 0 ;
43899
43900   arg1 = (Dali::Path *)jarg1;
43901   arg2 = (size_t)jarg2;
43902   {
43903     try {
43904       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43905     } catch (std::out_of_range& e) {
43906       {
43907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43908       };
43909     } catch (std::exception& e) {
43910       {
43911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43912       };
43913     } catch (Dali::DaliException e) {
43914       {
43915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43916       };
43917     } catch (...) {
43918       {
43919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43920       };
43921     }
43922   }
43923
43924   jresult = (void *)result;
43925   return jresult;
43926 }
43927
43928
43929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43930   void * jresult ;
43931   Dali::Path *arg1 = (Dali::Path *) 0 ;
43932   size_t arg2 ;
43933   Dali::Vector3 *result = 0 ;
43934
43935   arg1 = (Dali::Path *)jarg1;
43936   arg2 = (size_t)jarg2;
43937   {
43938     try {
43939       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43940     } catch (std::out_of_range& e) {
43941       {
43942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43943       };
43944     } catch (std::exception& e) {
43945       {
43946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43947       };
43948     } catch (Dali::DaliException e) {
43949       {
43950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43951       };
43952     } catch (...) {
43953       {
43954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43955       };
43956     }
43957   }
43958
43959   jresult = (void *)result;
43960   return jresult;
43961 }
43962
43963
43964 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43965   unsigned long jresult ;
43966   Dali::Path *arg1 = (Dali::Path *) 0 ;
43967   size_t result;
43968
43969   arg1 = (Dali::Path *)jarg1;
43970   {
43971     try {
43972       result = ((Dali::Path const *)arg1)->GetPointCount();
43973     } catch (std::out_of_range& e) {
43974       {
43975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43976       };
43977     } catch (std::exception& e) {
43978       {
43979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43980       };
43981     } catch (Dali::DaliException e) {
43982       {
43983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43984       };
43985     } catch (...) {
43986       {
43987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43988       };
43989     }
43990   }
43991
43992   jresult = (unsigned long)result;
43993   return jresult;
43994 }
43995
43996
43997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43998   void * jresult ;
43999   float arg1 ;
44000   Dali::TimePeriod *result = 0 ;
44001
44002   arg1 = (float)jarg1;
44003   {
44004     try {
44005       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44006     } catch (std::out_of_range& e) {
44007       {
44008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44009       };
44010     } catch (std::exception& e) {
44011       {
44012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44013       };
44014     } catch (Dali::DaliException e) {
44015       {
44016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44017       };
44018     } catch (...) {
44019       {
44020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44021       };
44022     }
44023   }
44024
44025   jresult = (void *)result;
44026   return jresult;
44027 }
44028
44029
44030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44031   void * jresult ;
44032   float arg1 ;
44033   float arg2 ;
44034   Dali::TimePeriod *result = 0 ;
44035
44036   arg1 = (float)jarg1;
44037   arg2 = (float)jarg2;
44038   {
44039     try {
44040       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44041     } catch (std::out_of_range& e) {
44042       {
44043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44044       };
44045     } catch (std::exception& e) {
44046       {
44047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44048       };
44049     } catch (Dali::DaliException e) {
44050       {
44051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44052       };
44053     } catch (...) {
44054       {
44055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44056       };
44057     }
44058   }
44059
44060   jresult = (void *)result;
44061   return jresult;
44062 }
44063
44064
44065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44066   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44067
44068   arg1 = (Dali::TimePeriod *)jarg1;
44069   {
44070     try {
44071       delete arg1;
44072     } catch (std::out_of_range& e) {
44073       {
44074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44075       };
44076     } catch (std::exception& e) {
44077       {
44078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44079       };
44080     } catch (Dali::DaliException e) {
44081       {
44082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44083       };
44084     } catch (...) {
44085       {
44086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44087       };
44088     }
44089   }
44090
44091 }
44092
44093
44094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44095   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44096   float arg2 ;
44097
44098   arg1 = (Dali::TimePeriod *)jarg1;
44099   arg2 = (float)jarg2;
44100   if (arg1) (arg1)->delaySeconds = arg2;
44101 }
44102
44103
44104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44105   float jresult ;
44106   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44107   float result;
44108
44109   arg1 = (Dali::TimePeriod *)jarg1;
44110   result = (float) ((arg1)->delaySeconds);
44111   jresult = result;
44112   return jresult;
44113 }
44114
44115
44116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44117   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44118   float arg2 ;
44119
44120   arg1 = (Dali::TimePeriod *)jarg1;
44121   arg2 = (float)jarg2;
44122   if (arg1) (arg1)->durationSeconds = arg2;
44123 }
44124
44125
44126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44127   float jresult ;
44128   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44129   float result;
44130
44131   arg1 = (Dali::TimePeriod *)jarg1;
44132   result = (float) ((arg1)->durationSeconds);
44133   jresult = result;
44134   return jresult;
44135 }
44136
44137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44138   int jresult ;
44139   int result;
44140
44141   result = (int)Dali::LinearConstrainer::Property::VALUE;
44142   jresult = (int)result;
44143   return jresult;
44144 }
44145
44146
44147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44148   int jresult ;
44149   int result;
44150
44151   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44152   jresult = (int)result;
44153   return jresult;
44154 }
44155
44156
44157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44158   void * jresult ;
44159   Dali::LinearConstrainer::Property *result = 0 ;
44160
44161   {
44162     try {
44163       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44164     } catch (std::out_of_range& e) {
44165       {
44166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44167       };
44168     } catch (std::exception& e) {
44169       {
44170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44171       };
44172     } catch (Dali::DaliException e) {
44173       {
44174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44175       };
44176     } catch (...) {
44177       {
44178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44179       };
44180     }
44181   }
44182
44183   jresult = (void *)result;
44184   return jresult;
44185 }
44186
44187
44188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44189   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44190
44191   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44192   {
44193     try {
44194       delete arg1;
44195     } catch (std::out_of_range& e) {
44196       {
44197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44198       };
44199     } catch (std::exception& e) {
44200       {
44201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44202       };
44203     } catch (Dali::DaliException e) {
44204       {
44205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44206       };
44207     } catch (...) {
44208       {
44209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44210       };
44211     }
44212   }
44213
44214 }
44215
44216
44217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44218   void * jresult ;
44219   Dali::LinearConstrainer result;
44220
44221   {
44222     try {
44223       result = Dali::LinearConstrainer::New();
44224     } catch (std::out_of_range& e) {
44225       {
44226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44227       };
44228     } catch (std::exception& e) {
44229       {
44230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44231       };
44232     } catch (Dali::DaliException e) {
44233       {
44234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44235       };
44236     } catch (...) {
44237       {
44238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44239       };
44240     }
44241   }
44242
44243   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44244   return jresult;
44245 }
44246
44247
44248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44249   void * jresult ;
44250   Dali::BaseHandle arg1 ;
44251   Dali::BaseHandle *argp1 ;
44252   Dali::LinearConstrainer result;
44253
44254   argp1 = (Dali::BaseHandle *)jarg1;
44255   if (!argp1) {
44256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44257     return 0;
44258   }
44259   arg1 = *argp1;
44260   {
44261     try {
44262       result = Dali::LinearConstrainer::DownCast(arg1);
44263     } catch (std::out_of_range& e) {
44264       {
44265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44266       };
44267     } catch (std::exception& e) {
44268       {
44269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44270       };
44271     } catch (Dali::DaliException e) {
44272       {
44273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44274       };
44275     } catch (...) {
44276       {
44277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44278       };
44279     }
44280   }
44281
44282   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44283   return jresult;
44284 }
44285
44286
44287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44288   void * jresult ;
44289   Dali::LinearConstrainer *result = 0 ;
44290
44291   {
44292     try {
44293       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44294     } catch (std::out_of_range& e) {
44295       {
44296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44297       };
44298     } catch (std::exception& e) {
44299       {
44300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44301       };
44302     } catch (Dali::DaliException e) {
44303       {
44304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44305       };
44306     } catch (...) {
44307       {
44308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44309       };
44310     }
44311   }
44312
44313   jresult = (void *)result;
44314   return jresult;
44315 }
44316
44317
44318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44319   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44320
44321   arg1 = (Dali::LinearConstrainer *)jarg1;
44322   {
44323     try {
44324       delete arg1;
44325     } catch (std::out_of_range& e) {
44326       {
44327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44328       };
44329     } catch (std::exception& e) {
44330       {
44331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44332       };
44333     } catch (Dali::DaliException e) {
44334       {
44335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44336       };
44337     } catch (...) {
44338       {
44339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44340       };
44341     }
44342   }
44343
44344 }
44345
44346
44347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44348   void * jresult ;
44349   Dali::LinearConstrainer *arg1 = 0 ;
44350   Dali::LinearConstrainer *result = 0 ;
44351
44352   arg1 = (Dali::LinearConstrainer *)jarg1;
44353   if (!arg1) {
44354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44355     return 0;
44356   }
44357   {
44358     try {
44359       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44360     } catch (std::out_of_range& e) {
44361       {
44362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44363       };
44364     } catch (std::exception& e) {
44365       {
44366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44367       };
44368     } catch (Dali::DaliException e) {
44369       {
44370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44371       };
44372     } catch (...) {
44373       {
44374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44375       };
44376     }
44377   }
44378
44379   jresult = (void *)result;
44380   return jresult;
44381 }
44382
44383
44384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44385   void * jresult ;
44386   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44387   Dali::LinearConstrainer *arg2 = 0 ;
44388   Dali::LinearConstrainer *result = 0 ;
44389
44390   arg1 = (Dali::LinearConstrainer *)jarg1;
44391   arg2 = (Dali::LinearConstrainer *)jarg2;
44392   if (!arg2) {
44393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44394     return 0;
44395   }
44396   {
44397     try {
44398       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44399     } catch (std::out_of_range& e) {
44400       {
44401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44402       };
44403     } catch (std::exception& e) {
44404       {
44405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44406       };
44407     } catch (Dali::DaliException e) {
44408       {
44409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44410       };
44411     } catch (...) {
44412       {
44413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44414       };
44415     }
44416   }
44417
44418   jresult = (void *)result;
44419   return jresult;
44420 }
44421
44422
44423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44424   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44425   SwigValueWrapper< Dali::Property > arg2 ;
44426   SwigValueWrapper< Dali::Property > arg3 ;
44427   Dali::Vector2 *arg4 = 0 ;
44428   Dali::Vector2 *arg5 = 0 ;
44429   Dali::Property *argp2 ;
44430   Dali::Property *argp3 ;
44431
44432   arg1 = (Dali::LinearConstrainer *)jarg1;
44433   argp2 = (Dali::Property *)jarg2;
44434   if (!argp2) {
44435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44436     return ;
44437   }
44438   arg2 = *argp2;
44439   argp3 = (Dali::Property *)jarg3;
44440   if (!argp3) {
44441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44442     return ;
44443   }
44444   arg3 = *argp3;
44445   arg4 = (Dali::Vector2 *)jarg4;
44446   if (!arg4) {
44447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44448     return ;
44449   }
44450   arg5 = (Dali::Vector2 *)jarg5;
44451   if (!arg5) {
44452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44453     return ;
44454   }
44455   {
44456     try {
44457       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44458     } catch (std::out_of_range& e) {
44459       {
44460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44461       };
44462     } catch (std::exception& e) {
44463       {
44464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44465       };
44466     } catch (Dali::DaliException e) {
44467       {
44468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44469       };
44470     } catch (...) {
44471       {
44472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44473       };
44474     }
44475   }
44476
44477 }
44478
44479
44480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44481   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44482   SwigValueWrapper< Dali::Property > arg2 ;
44483   SwigValueWrapper< Dali::Property > arg3 ;
44484   Dali::Vector2 *arg4 = 0 ;
44485   Dali::Property *argp2 ;
44486   Dali::Property *argp3 ;
44487
44488   arg1 = (Dali::LinearConstrainer *)jarg1;
44489   argp2 = (Dali::Property *)jarg2;
44490   if (!argp2) {
44491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44492     return ;
44493   }
44494   arg2 = *argp2;
44495   argp3 = (Dali::Property *)jarg3;
44496   if (!argp3) {
44497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44498     return ;
44499   }
44500   arg3 = *argp3;
44501   arg4 = (Dali::Vector2 *)jarg4;
44502   if (!arg4) {
44503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44504     return ;
44505   }
44506   {
44507     try {
44508       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44509     } catch (std::out_of_range& e) {
44510       {
44511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44512       };
44513     } catch (std::exception& e) {
44514       {
44515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44516       };
44517     } catch (Dali::DaliException e) {
44518       {
44519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44520       };
44521     } catch (...) {
44522       {
44523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44524       };
44525     }
44526   }
44527
44528 }
44529
44530
44531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44532   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44533   Dali::Handle *arg2 = 0 ;
44534
44535   arg1 = (Dali::LinearConstrainer *)jarg1;
44536   arg2 = (Dali::Handle *)jarg2;
44537   if (!arg2) {
44538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44539     return ;
44540   }
44541   {
44542     try {
44543       (arg1)->Remove(*arg2);
44544     } catch (std::out_of_range& e) {
44545       {
44546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44547       };
44548     } catch (std::exception& e) {
44549       {
44550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44551       };
44552     } catch (Dali::DaliException e) {
44553       {
44554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44555       };
44556     } catch (...) {
44557       {
44558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44559       };
44560     }
44561   }
44562
44563 }
44564
44565
44566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44567   int jresult ;
44568   int result;
44569
44570   result = (int)Dali::PathConstrainer::Property::FORWARD;
44571   jresult = (int)result;
44572   return jresult;
44573 }
44574
44575
44576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44577   int jresult ;
44578   int result;
44579
44580   result = (int)Dali::PathConstrainer::Property::POINTS;
44581   jresult = (int)result;
44582   return jresult;
44583 }
44584
44585
44586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44587   int jresult ;
44588   int result;
44589
44590   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44591   jresult = (int)result;
44592   return jresult;
44593 }
44594
44595
44596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44597   void * jresult ;
44598   Dali::PathConstrainer::Property *result = 0 ;
44599
44600   {
44601     try {
44602       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44603     } catch (std::out_of_range& e) {
44604       {
44605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44606       };
44607     } catch (std::exception& e) {
44608       {
44609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44610       };
44611     } catch (Dali::DaliException e) {
44612       {
44613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44614       };
44615     } catch (...) {
44616       {
44617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44618       };
44619     }
44620   }
44621
44622   jresult = (void *)result;
44623   return jresult;
44624 }
44625
44626
44627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44628   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44629
44630   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44631   {
44632     try {
44633       delete arg1;
44634     } catch (std::out_of_range& e) {
44635       {
44636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44637       };
44638     } catch (std::exception& e) {
44639       {
44640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44641       };
44642     } catch (Dali::DaliException e) {
44643       {
44644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44645       };
44646     } catch (...) {
44647       {
44648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44649       };
44650     }
44651   }
44652
44653 }
44654
44655
44656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44657   void * jresult ;
44658   Dali::PathConstrainer result;
44659
44660   {
44661     try {
44662       result = Dali::PathConstrainer::New();
44663     } catch (std::out_of_range& e) {
44664       {
44665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44666       };
44667     } catch (std::exception& e) {
44668       {
44669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44670       };
44671     } catch (Dali::DaliException e) {
44672       {
44673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44674       };
44675     } catch (...) {
44676       {
44677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44678       };
44679     }
44680   }
44681
44682   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44683   return jresult;
44684 }
44685
44686
44687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44688   void * jresult ;
44689   Dali::BaseHandle arg1 ;
44690   Dali::BaseHandle *argp1 ;
44691   Dali::PathConstrainer result;
44692
44693   argp1 = (Dali::BaseHandle *)jarg1;
44694   if (!argp1) {
44695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44696     return 0;
44697   }
44698   arg1 = *argp1;
44699   {
44700     try {
44701       result = Dali::PathConstrainer::DownCast(arg1);
44702     } catch (std::out_of_range& e) {
44703       {
44704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44705       };
44706     } catch (std::exception& e) {
44707       {
44708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44709       };
44710     } catch (Dali::DaliException e) {
44711       {
44712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44713       };
44714     } catch (...) {
44715       {
44716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44717       };
44718     }
44719   }
44720
44721   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44722   return jresult;
44723 }
44724
44725
44726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44727   void * jresult ;
44728   Dali::PathConstrainer *result = 0 ;
44729
44730   {
44731     try {
44732       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44733     } catch (std::out_of_range& e) {
44734       {
44735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44736       };
44737     } catch (std::exception& e) {
44738       {
44739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44740       };
44741     } catch (Dali::DaliException e) {
44742       {
44743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44744       };
44745     } catch (...) {
44746       {
44747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44748       };
44749     }
44750   }
44751
44752   jresult = (void *)result;
44753   return jresult;
44754 }
44755
44756
44757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44758   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44759
44760   arg1 = (Dali::PathConstrainer *)jarg1;
44761   {
44762     try {
44763       delete arg1;
44764     } catch (std::out_of_range& e) {
44765       {
44766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44767       };
44768     } catch (std::exception& e) {
44769       {
44770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44771       };
44772     } catch (Dali::DaliException e) {
44773       {
44774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44775       };
44776     } catch (...) {
44777       {
44778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44779       };
44780     }
44781   }
44782
44783 }
44784
44785
44786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44787   void * jresult ;
44788   Dali::PathConstrainer *arg1 = 0 ;
44789   Dali::PathConstrainer *result = 0 ;
44790
44791   arg1 = (Dali::PathConstrainer *)jarg1;
44792   if (!arg1) {
44793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44794     return 0;
44795   }
44796   {
44797     try {
44798       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44799     } catch (std::out_of_range& e) {
44800       {
44801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44802       };
44803     } catch (std::exception& e) {
44804       {
44805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44806       };
44807     } catch (Dali::DaliException e) {
44808       {
44809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44810       };
44811     } catch (...) {
44812       {
44813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44814       };
44815     }
44816   }
44817
44818   jresult = (void *)result;
44819   return jresult;
44820 }
44821
44822
44823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44824   void * jresult ;
44825   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44826   Dali::PathConstrainer *arg2 = 0 ;
44827   Dali::PathConstrainer *result = 0 ;
44828
44829   arg1 = (Dali::PathConstrainer *)jarg1;
44830   arg2 = (Dali::PathConstrainer *)jarg2;
44831   if (!arg2) {
44832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44833     return 0;
44834   }
44835   {
44836     try {
44837       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44838     } catch (std::out_of_range& e) {
44839       {
44840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44841       };
44842     } catch (std::exception& e) {
44843       {
44844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44845       };
44846     } catch (Dali::DaliException e) {
44847       {
44848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44849       };
44850     } catch (...) {
44851       {
44852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44853       };
44854     }
44855   }
44856
44857   jresult = (void *)result;
44858   return jresult;
44859 }
44860
44861
44862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44863   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44864   SwigValueWrapper< Dali::Property > arg2 ;
44865   SwigValueWrapper< Dali::Property > arg3 ;
44866   Dali::Vector2 *arg4 = 0 ;
44867   Dali::Vector2 *arg5 = 0 ;
44868   Dali::Property *argp2 ;
44869   Dali::Property *argp3 ;
44870
44871   arg1 = (Dali::PathConstrainer *)jarg1;
44872   argp2 = (Dali::Property *)jarg2;
44873   if (!argp2) {
44874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44875     return ;
44876   }
44877   arg2 = *argp2;
44878   argp3 = (Dali::Property *)jarg3;
44879   if (!argp3) {
44880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44881     return ;
44882   }
44883   arg3 = *argp3;
44884   arg4 = (Dali::Vector2 *)jarg4;
44885   if (!arg4) {
44886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44887     return ;
44888   }
44889   arg5 = (Dali::Vector2 *)jarg5;
44890   if (!arg5) {
44891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44892     return ;
44893   }
44894   {
44895     try {
44896       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44897     } catch (std::out_of_range& e) {
44898       {
44899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44900       };
44901     } catch (std::exception& e) {
44902       {
44903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44904       };
44905     } catch (Dali::DaliException e) {
44906       {
44907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44908       };
44909     } catch (...) {
44910       {
44911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44912       };
44913     }
44914   }
44915
44916 }
44917
44918
44919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44920   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44921   SwigValueWrapper< Dali::Property > arg2 ;
44922   SwigValueWrapper< Dali::Property > arg3 ;
44923   Dali::Vector2 *arg4 = 0 ;
44924   Dali::Property *argp2 ;
44925   Dali::Property *argp3 ;
44926
44927   arg1 = (Dali::PathConstrainer *)jarg1;
44928   argp2 = (Dali::Property *)jarg2;
44929   if (!argp2) {
44930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44931     return ;
44932   }
44933   arg2 = *argp2;
44934   argp3 = (Dali::Property *)jarg3;
44935   if (!argp3) {
44936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44937     return ;
44938   }
44939   arg3 = *argp3;
44940   arg4 = (Dali::Vector2 *)jarg4;
44941   if (!arg4) {
44942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44943     return ;
44944   }
44945   {
44946     try {
44947       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44948     } catch (std::out_of_range& e) {
44949       {
44950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44951       };
44952     } catch (std::exception& e) {
44953       {
44954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44955       };
44956     } catch (Dali::DaliException e) {
44957       {
44958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44959       };
44960     } catch (...) {
44961       {
44962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44963       };
44964     }
44965   }
44966
44967 }
44968
44969
44970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44971   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44972   Dali::Handle *arg2 = 0 ;
44973
44974   arg1 = (Dali::PathConstrainer *)jarg1;
44975   arg2 = (Dali::Handle *)jarg2;
44976   if (!arg2) {
44977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44978     return ;
44979   }
44980   {
44981     try {
44982       (arg1)->Remove(*arg2);
44983     } catch (std::out_of_range& e) {
44984       {
44985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44986       };
44987     } catch (std::exception& e) {
44988       {
44989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44990       };
44991     } catch (Dali::DaliException e) {
44992       {
44993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44994       };
44995     } catch (...) {
44996       {
44997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44998       };
44999     }
45000   }
45001
45002 }
45003
45004
45005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45006   int jresult ;
45007   Dali::FittingMode::Type result;
45008
45009   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45010   jresult = (int)result;
45011   return jresult;
45012 }
45013
45014
45015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45016   int jresult ;
45017   Dali::SamplingMode::Type result;
45018
45019   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45020   jresult = (int)result;
45021   return jresult;
45022 }
45023
45024
45025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45026   void * jresult ;
45027   Dali::BufferImage *result = 0 ;
45028
45029   {
45030     try {
45031       result = (Dali::BufferImage *)new Dali::BufferImage();
45032     } catch (std::out_of_range& e) {
45033       {
45034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45035       };
45036     } catch (std::exception& e) {
45037       {
45038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45039       };
45040     } catch (Dali::DaliException e) {
45041       {
45042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45043       };
45044     } catch (...) {
45045       {
45046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45047       };
45048     }
45049   }
45050
45051   jresult = (void *)result;
45052   return jresult;
45053 }
45054
45055
45056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45057   void * jresult ;
45058   unsigned int arg1 ;
45059   unsigned int arg2 ;
45060   Dali::Pixel::Format arg3 ;
45061   Dali::BufferImage result;
45062
45063   arg1 = (unsigned int)jarg1;
45064   arg2 = (unsigned int)jarg2;
45065   arg3 = (Dali::Pixel::Format)jarg3;
45066   {
45067     try {
45068       result = Dali::BufferImage::New(arg1,arg2,arg3);
45069     } catch (std::out_of_range& e) {
45070       {
45071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45072       };
45073     } catch (std::exception& e) {
45074       {
45075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45076       };
45077     } catch (Dali::DaliException e) {
45078       {
45079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45080       };
45081     } catch (...) {
45082       {
45083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45084       };
45085     }
45086   }
45087
45088   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45089   return jresult;
45090 }
45091
45092
45093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45094   void * jresult ;
45095   unsigned int arg1 ;
45096   unsigned int arg2 ;
45097   Dali::BufferImage result;
45098
45099   arg1 = (unsigned int)jarg1;
45100   arg2 = (unsigned int)jarg2;
45101   {
45102     try {
45103       result = Dali::BufferImage::New(arg1,arg2);
45104     } catch (std::out_of_range& e) {
45105       {
45106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45107       };
45108     } catch (std::exception& e) {
45109       {
45110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45111       };
45112     } catch (Dali::DaliException e) {
45113       {
45114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45115       };
45116     } catch (...) {
45117       {
45118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45119       };
45120     }
45121   }
45122
45123   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45124   return jresult;
45125 }
45126
45127
45128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45129   void * jresult ;
45130   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45131   unsigned int arg2 ;
45132   unsigned int arg3 ;
45133   Dali::Pixel::Format arg4 ;
45134   unsigned int arg5 ;
45135   Dali::BufferImage result;
45136
45137   arg1 = jarg1;
45138   arg2 = (unsigned int)jarg2;
45139   arg3 = (unsigned int)jarg3;
45140   arg4 = (Dali::Pixel::Format)jarg4;
45141   arg5 = (unsigned int)jarg5;
45142   {
45143     try {
45144       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45145     } catch (std::out_of_range& e) {
45146       {
45147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45148       };
45149     } catch (std::exception& e) {
45150       {
45151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45152       };
45153     } catch (Dali::DaliException e) {
45154       {
45155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45156       };
45157     } catch (...) {
45158       {
45159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45160       };
45161     }
45162   }
45163
45164   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45165
45166
45167   return jresult;
45168 }
45169
45170
45171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45172   void * jresult ;
45173   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45174   unsigned int arg2 ;
45175   unsigned int arg3 ;
45176   Dali::Pixel::Format arg4 ;
45177   Dali::BufferImage result;
45178
45179   arg1 = jarg1;
45180   arg2 = (unsigned int)jarg2;
45181   arg3 = (unsigned int)jarg3;
45182   arg4 = (Dali::Pixel::Format)jarg4;
45183   {
45184     try {
45185       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45186     } catch (std::out_of_range& e) {
45187       {
45188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45189       };
45190     } catch (std::exception& e) {
45191       {
45192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45193       };
45194     } catch (Dali::DaliException e) {
45195       {
45196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45197       };
45198     } catch (...) {
45199       {
45200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45201       };
45202     }
45203   }
45204
45205   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45206
45207
45208   return jresult;
45209 }
45210
45211
45212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45213   void * jresult ;
45214   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45215   unsigned int arg2 ;
45216   unsigned int arg3 ;
45217   Dali::BufferImage result;
45218
45219   arg1 = jarg1;
45220   arg2 = (unsigned int)jarg2;
45221   arg3 = (unsigned int)jarg3;
45222   {
45223     try {
45224       result = Dali::BufferImage::New(arg1,arg2,arg3);
45225     } catch (std::out_of_range& e) {
45226       {
45227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45228       };
45229     } catch (std::exception& e) {
45230       {
45231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45232       };
45233     } catch (Dali::DaliException e) {
45234       {
45235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45236       };
45237     } catch (...) {
45238       {
45239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45240       };
45241     }
45242   }
45243
45244   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45245
45246
45247   return jresult;
45248 }
45249
45250
45251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45252   void * jresult ;
45253   Dali::BaseHandle arg1 ;
45254   Dali::BaseHandle *argp1 ;
45255   Dali::BufferImage result;
45256
45257   argp1 = (Dali::BaseHandle *)jarg1;
45258   if (!argp1) {
45259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45260     return 0;
45261   }
45262   arg1 = *argp1;
45263   {
45264     try {
45265       result = Dali::BufferImage::DownCast(arg1);
45266     } catch (std::out_of_range& e) {
45267       {
45268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45269       };
45270     } catch (std::exception& e) {
45271       {
45272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45273       };
45274     } catch (Dali::DaliException e) {
45275       {
45276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45277       };
45278     } catch (...) {
45279       {
45280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45281       };
45282     }
45283   }
45284
45285   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45286   return jresult;
45287 }
45288
45289
45290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45291   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45292
45293   arg1 = (Dali::BufferImage *)jarg1;
45294   {
45295     try {
45296       delete arg1;
45297     } catch (std::out_of_range& e) {
45298       {
45299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45300       };
45301     } catch (std::exception& e) {
45302       {
45303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45304       };
45305     } catch (Dali::DaliException e) {
45306       {
45307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45308       };
45309     } catch (...) {
45310       {
45311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45312       };
45313     }
45314   }
45315
45316 }
45317
45318
45319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45320   void * jresult ;
45321   Dali::BufferImage *arg1 = 0 ;
45322   Dali::BufferImage *result = 0 ;
45323
45324   arg1 = (Dali::BufferImage *)jarg1;
45325   if (!arg1) {
45326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45327     return 0;
45328   }
45329   {
45330     try {
45331       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45332     } catch (std::out_of_range& e) {
45333       {
45334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45335       };
45336     } catch (std::exception& e) {
45337       {
45338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45339       };
45340     } catch (Dali::DaliException e) {
45341       {
45342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45343       };
45344     } catch (...) {
45345       {
45346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45347       };
45348     }
45349   }
45350
45351   jresult = (void *)result;
45352   return jresult;
45353 }
45354
45355
45356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45357   void * jresult ;
45358   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45359   Dali::BufferImage *arg2 = 0 ;
45360   Dali::BufferImage *result = 0 ;
45361
45362   arg1 = (Dali::BufferImage *)jarg1;
45363   arg2 = (Dali::BufferImage *)jarg2;
45364   if (!arg2) {
45365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45366     return 0;
45367   }
45368   {
45369     try {
45370       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45371     } catch (std::out_of_range& e) {
45372       {
45373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45374       };
45375     } catch (std::exception& e) {
45376       {
45377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45378       };
45379     } catch (Dali::DaliException e) {
45380       {
45381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45382       };
45383     } catch (...) {
45384       {
45385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45386       };
45387     }
45388   }
45389
45390   jresult = (void *)result;
45391   return jresult;
45392 }
45393
45394
45395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45396   void * jresult ;
45397   Dali::BufferImage result;
45398
45399   {
45400     try {
45401       result = Dali::BufferImage::WHITE();
45402     } catch (std::out_of_range& e) {
45403       {
45404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45405       };
45406     } catch (std::exception& e) {
45407       {
45408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45409       };
45410     } catch (Dali::DaliException e) {
45411       {
45412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45413       };
45414     } catch (...) {
45415       {
45416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45417       };
45418     }
45419   }
45420
45421   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45422   return jresult;
45423 }
45424
45425
45426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45427   void * jresult ;
45428   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45429   Dali::PixelBuffer *result = 0 ;
45430
45431   arg1 = (Dali::BufferImage *)jarg1;
45432   {
45433     try {
45434       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45435     } catch (std::out_of_range& e) {
45436       {
45437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45438       };
45439     } catch (std::exception& e) {
45440       {
45441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45442       };
45443     } catch (Dali::DaliException e) {
45444       {
45445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45446       };
45447     } catch (...) {
45448       {
45449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45450       };
45451     }
45452   }
45453
45454   jresult = (void *)result;
45455   return jresult;
45456 }
45457
45458
45459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45460   unsigned int jresult ;
45461   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45462   unsigned int result;
45463
45464   arg1 = (Dali::BufferImage *)jarg1;
45465   {
45466     try {
45467       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45468     } catch (std::out_of_range& e) {
45469       {
45470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45471       };
45472     } catch (std::exception& e) {
45473       {
45474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45475       };
45476     } catch (Dali::DaliException e) {
45477       {
45478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45479       };
45480     } catch (...) {
45481       {
45482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45483       };
45484     }
45485   }
45486
45487   jresult = result;
45488   return jresult;
45489 }
45490
45491
45492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45493   unsigned int jresult ;
45494   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45495   unsigned int result;
45496
45497   arg1 = (Dali::BufferImage *)jarg1;
45498   {
45499     try {
45500       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45501     } catch (std::out_of_range& e) {
45502       {
45503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45504       };
45505     } catch (std::exception& e) {
45506       {
45507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45508       };
45509     } catch (Dali::DaliException e) {
45510       {
45511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45512       };
45513     } catch (...) {
45514       {
45515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45516       };
45517     }
45518   }
45519
45520   jresult = result;
45521   return jresult;
45522 }
45523
45524
45525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45526   int jresult ;
45527   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45528   Dali::Pixel::Format result;
45529
45530   arg1 = (Dali::BufferImage *)jarg1;
45531   {
45532     try {
45533       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45534     } catch (std::out_of_range& e) {
45535       {
45536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45537       };
45538     } catch (std::exception& e) {
45539       {
45540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45541       };
45542     } catch (Dali::DaliException e) {
45543       {
45544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45545       };
45546     } catch (...) {
45547       {
45548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45549       };
45550     }
45551   }
45552
45553   jresult = (int)result;
45554   return jresult;
45555 }
45556
45557
45558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45559   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45560
45561   arg1 = (Dali::BufferImage *)jarg1;
45562   {
45563     try {
45564       (arg1)->Update();
45565     } catch (std::out_of_range& e) {
45566       {
45567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45568       };
45569     } catch (std::exception& e) {
45570       {
45571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45572       };
45573     } catch (Dali::DaliException e) {
45574       {
45575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45576       };
45577     } catch (...) {
45578       {
45579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45580       };
45581     }
45582   }
45583
45584 }
45585
45586
45587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45588   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45589   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45590   Dali::RectArea *argp2 ;
45591
45592   arg1 = (Dali::BufferImage *)jarg1;
45593   argp2 = (Dali::RectArea *)jarg2;
45594   if (!argp2) {
45595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45596     return ;
45597   }
45598   arg2 = *argp2;
45599   {
45600     try {
45601       (arg1)->Update(arg2);
45602     } catch (std::out_of_range& e) {
45603       {
45604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45605       };
45606     } catch (std::exception& e) {
45607       {
45608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45609       };
45610     } catch (Dali::DaliException e) {
45611       {
45612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45613       };
45614     } catch (...) {
45615       {
45616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45617       };
45618     }
45619   }
45620
45621 }
45622
45623
45624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45625   unsigned int jresult ;
45626   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45627   bool result;
45628
45629   arg1 = (Dali::BufferImage *)jarg1;
45630   {
45631     try {
45632       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45633     } catch (std::out_of_range& e) {
45634       {
45635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45636       };
45637     } catch (std::exception& e) {
45638       {
45639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45640       };
45641     } catch (Dali::DaliException e) {
45642       {
45643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45644       };
45645     } catch (...) {
45646       {
45647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45648       };
45649     }
45650   }
45651
45652   jresult = result;
45653   return jresult;
45654 }
45655
45656
45657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45658   void * jresult ;
45659   Dali::EncodedBufferImage *result = 0 ;
45660
45661   {
45662     try {
45663       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45664     } catch (std::out_of_range& e) {
45665       {
45666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45667       };
45668     } catch (std::exception& e) {
45669       {
45670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45671       };
45672     } catch (Dali::DaliException e) {
45673       {
45674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45675       };
45676     } catch (...) {
45677       {
45678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45679       };
45680     }
45681   }
45682
45683   jresult = (void *)result;
45684   return jresult;
45685 }
45686
45687
45688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45689   void * jresult ;
45690   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45691   std::size_t arg2 ;
45692   Dali::EncodedBufferImage result;
45693
45694   arg1 = (uint8_t *)jarg1;
45695   arg2 = (std::size_t)jarg2;
45696   {
45697     try {
45698       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45699     } catch (std::out_of_range& e) {
45700       {
45701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45702       };
45703     } catch (std::exception& e) {
45704       {
45705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45706       };
45707     } catch (Dali::DaliException e) {
45708       {
45709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45710       };
45711     } catch (...) {
45712       {
45713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45714       };
45715     }
45716   }
45717
45718   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45719   return jresult;
45720 }
45721
45722
45723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45724   void * jresult ;
45725   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45726   std::size_t arg2 ;
45727   Dali::ImageDimensions arg3 ;
45728   Dali::FittingMode::Type arg4 ;
45729   Dali::SamplingMode::Type arg5 ;
45730   bool arg6 ;
45731   Dali::ImageDimensions *argp3 ;
45732   Dali::EncodedBufferImage result;
45733
45734   arg1 = (uint8_t *)jarg1;
45735   arg2 = (std::size_t)jarg2;
45736   argp3 = (Dali::ImageDimensions *)jarg3;
45737   if (!argp3) {
45738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45739     return 0;
45740   }
45741   arg3 = *argp3;
45742   arg4 = (Dali::FittingMode::Type)jarg4;
45743   arg5 = (Dali::SamplingMode::Type)jarg5;
45744   arg6 = jarg6 ? true : false;
45745   {
45746     try {
45747       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45748     } catch (std::out_of_range& e) {
45749       {
45750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45751       };
45752     } catch (std::exception& e) {
45753       {
45754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45755       };
45756     } catch (Dali::DaliException e) {
45757       {
45758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45759       };
45760     } catch (...) {
45761       {
45762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45763       };
45764     }
45765   }
45766
45767   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45768   return jresult;
45769 }
45770
45771
45772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45773   void * jresult ;
45774   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45775   std::size_t arg2 ;
45776   Dali::ImageDimensions arg3 ;
45777   Dali::FittingMode::Type arg4 ;
45778   Dali::SamplingMode::Type arg5 ;
45779   Dali::ImageDimensions *argp3 ;
45780   Dali::EncodedBufferImage result;
45781
45782   arg1 = (uint8_t *)jarg1;
45783   arg2 = (std::size_t)jarg2;
45784   argp3 = (Dali::ImageDimensions *)jarg3;
45785   if (!argp3) {
45786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45787     return 0;
45788   }
45789   arg3 = *argp3;
45790   arg4 = (Dali::FittingMode::Type)jarg4;
45791   arg5 = (Dali::SamplingMode::Type)jarg5;
45792   {
45793     try {
45794       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45795     } catch (std::out_of_range& e) {
45796       {
45797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45798       };
45799     } catch (std::exception& e) {
45800       {
45801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45802       };
45803     } catch (Dali::DaliException e) {
45804       {
45805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45806       };
45807     } catch (...) {
45808       {
45809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45810       };
45811     }
45812   }
45813
45814   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45815   return jresult;
45816 }
45817
45818
45819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45820   void * jresult ;
45821   Dali::BaseHandle arg1 ;
45822   Dali::BaseHandle *argp1 ;
45823   Dali::EncodedBufferImage result;
45824
45825   argp1 = (Dali::BaseHandle *)jarg1;
45826   if (!argp1) {
45827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45828     return 0;
45829   }
45830   arg1 = *argp1;
45831   {
45832     try {
45833       result = Dali::EncodedBufferImage::DownCast(arg1);
45834     } catch (std::out_of_range& e) {
45835       {
45836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45837       };
45838     } catch (std::exception& e) {
45839       {
45840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45841       };
45842     } catch (Dali::DaliException e) {
45843       {
45844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45845       };
45846     } catch (...) {
45847       {
45848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45849       };
45850     }
45851   }
45852
45853   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45854   return jresult;
45855 }
45856
45857
45858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45859   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45860
45861   arg1 = (Dali::EncodedBufferImage *)jarg1;
45862   {
45863     try {
45864       delete arg1;
45865     } catch (std::out_of_range& e) {
45866       {
45867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45868       };
45869     } catch (std::exception& e) {
45870       {
45871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45872       };
45873     } catch (Dali::DaliException e) {
45874       {
45875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45876       };
45877     } catch (...) {
45878       {
45879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45880       };
45881     }
45882   }
45883
45884 }
45885
45886
45887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45888   void * jresult ;
45889   Dali::EncodedBufferImage *arg1 = 0 ;
45890   Dali::EncodedBufferImage *result = 0 ;
45891
45892   arg1 = (Dali::EncodedBufferImage *)jarg1;
45893   if (!arg1) {
45894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45895     return 0;
45896   }
45897   {
45898     try {
45899       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45900     } catch (std::out_of_range& e) {
45901       {
45902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45903       };
45904     } catch (std::exception& e) {
45905       {
45906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45907       };
45908     } catch (Dali::DaliException e) {
45909       {
45910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45911       };
45912     } catch (...) {
45913       {
45914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45915       };
45916     }
45917   }
45918
45919   jresult = (void *)result;
45920   return jresult;
45921 }
45922
45923
45924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45925   void * jresult ;
45926   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45927   Dali::EncodedBufferImage *arg2 = 0 ;
45928   Dali::EncodedBufferImage *result = 0 ;
45929
45930   arg1 = (Dali::EncodedBufferImage *)jarg1;
45931   arg2 = (Dali::EncodedBufferImage *)jarg2;
45932   if (!arg2) {
45933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45934     return 0;
45935   }
45936   {
45937     try {
45938       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45939     } catch (std::out_of_range& e) {
45940       {
45941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45942       };
45943     } catch (std::exception& e) {
45944       {
45945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45946       };
45947     } catch (Dali::DaliException e) {
45948       {
45949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45950       };
45951     } catch (...) {
45952       {
45953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45954       };
45955     }
45956   }
45957
45958   jresult = (void *)result;
45959   return jresult;
45960 }
45961
45962
45963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45964   void * jresult ;
45965   Dali::NativeImage *result = 0 ;
45966
45967   {
45968     try {
45969       result = (Dali::NativeImage *)new Dali::NativeImage();
45970     } catch (std::out_of_range& e) {
45971       {
45972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45973       };
45974     } catch (std::exception& e) {
45975       {
45976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45977       };
45978     } catch (Dali::DaliException e) {
45979       {
45980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45981       };
45982     } catch (...) {
45983       {
45984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45985       };
45986     }
45987   }
45988
45989   jresult = (void *)result;
45990   return jresult;
45991 }
45992
45993
45994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45995   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45996
45997   arg1 = (Dali::NativeImage *)jarg1;
45998   {
45999     try {
46000       delete arg1;
46001     } catch (std::out_of_range& e) {
46002       {
46003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46004       };
46005     } catch (std::exception& e) {
46006       {
46007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46008       };
46009     } catch (Dali::DaliException e) {
46010       {
46011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46012       };
46013     } catch (...) {
46014       {
46015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46016       };
46017     }
46018   }
46019
46020 }
46021
46022
46023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46024   void * jresult ;
46025   Dali::NativeImage *arg1 = 0 ;
46026   Dali::NativeImage *result = 0 ;
46027
46028   arg1 = (Dali::NativeImage *)jarg1;
46029   if (!arg1) {
46030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46031     return 0;
46032   }
46033   {
46034     try {
46035       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46036     } catch (std::out_of_range& e) {
46037       {
46038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46039       };
46040     } catch (std::exception& e) {
46041       {
46042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46043       };
46044     } catch (Dali::DaliException e) {
46045       {
46046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46047       };
46048     } catch (...) {
46049       {
46050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46051       };
46052     }
46053   }
46054
46055   jresult = (void *)result;
46056   return jresult;
46057 }
46058
46059
46060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46061   void * jresult ;
46062   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46063   Dali::NativeImage *arg2 = 0 ;
46064   Dali::NativeImage *result = 0 ;
46065
46066   arg1 = (Dali::NativeImage *)jarg1;
46067   arg2 = (Dali::NativeImage *)jarg2;
46068   if (!arg2) {
46069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46070     return 0;
46071   }
46072   {
46073     try {
46074       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46075     } catch (std::out_of_range& e) {
46076       {
46077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46078       };
46079     } catch (std::exception& e) {
46080       {
46081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46082       };
46083     } catch (Dali::DaliException e) {
46084       {
46085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46086       };
46087     } catch (...) {
46088       {
46089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46090       };
46091     }
46092   }
46093
46094   jresult = (void *)result;
46095   return jresult;
46096 }
46097
46098
46099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46100   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46101
46102   arg1 = (Dali::NativeImage *)jarg1;
46103   {
46104     try {
46105       (arg1)->CreateGlTexture();
46106     } catch (std::out_of_range& e) {
46107       {
46108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46109       };
46110     } catch (std::exception& e) {
46111       {
46112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46113       };
46114     } catch (Dali::DaliException e) {
46115       {
46116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46117       };
46118     } catch (...) {
46119       {
46120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46121       };
46122     }
46123   }
46124
46125 }
46126
46127
46128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46129   void * jresult ;
46130   NativeImageInterface *arg1 = 0 ;
46131   Dali::NativeImage result;
46132
46133   arg1 = (NativeImageInterface *)jarg1;
46134   if (!arg1) {
46135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46136     return 0;
46137   }
46138   {
46139     try {
46140       result = Dali::NativeImage::New(*arg1);
46141     } catch (std::out_of_range& e) {
46142       {
46143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46144       };
46145     } catch (std::exception& e) {
46146       {
46147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46148       };
46149     } catch (Dali::DaliException e) {
46150       {
46151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46152       };
46153     } catch (...) {
46154       {
46155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46156       };
46157     }
46158   }
46159
46160   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46161   return jresult;
46162 }
46163
46164
46165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46166   void * jresult ;
46167   Dali::BaseHandle arg1 ;
46168   Dali::BaseHandle *argp1 ;
46169   Dali::NativeImage result;
46170
46171   argp1 = (Dali::BaseHandle *)jarg1;
46172   if (!argp1) {
46173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46174     return 0;
46175   }
46176   arg1 = *argp1;
46177   {
46178     try {
46179       result = Dali::NativeImage::DownCast(arg1);
46180     } catch (std::out_of_range& e) {
46181       {
46182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46183       };
46184     } catch (std::exception& e) {
46185       {
46186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46187       };
46188     } catch (Dali::DaliException e) {
46189       {
46190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46191       };
46192     } catch (...) {
46193       {
46194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46195       };
46196     }
46197   }
46198
46199   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46200   return jresult;
46201 }
46202
46203
46204 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46205   char * jresult ;
46206   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46207   char *result = 0 ;
46208
46209   arg1 = (Dali::NativeImage *)jarg1;
46210   {
46211     try {
46212       result = (char *)(arg1)->GetCustomFragmentPreFix();
46213     } catch (std::out_of_range& e) {
46214       {
46215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46216       };
46217     } catch (std::exception& e) {
46218       {
46219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46220       };
46221     } catch (Dali::DaliException e) {
46222       {
46223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46224       };
46225     } catch (...) {
46226       {
46227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46228       };
46229     }
46230   }
46231
46232   jresult = SWIG_csharp_string_callback((const char *)result);
46233   return jresult;
46234 }
46235
46236
46237 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46238   char * jresult ;
46239   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46240   char *result = 0 ;
46241
46242   arg1 = (Dali::NativeImage *)jarg1;
46243   {
46244     try {
46245       result = (char *)(arg1)->GetCustomSamplerTypename();
46246     } catch (std::out_of_range& e) {
46247       {
46248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46249       };
46250     } catch (std::exception& e) {
46251       {
46252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46253       };
46254     } catch (Dali::DaliException e) {
46255       {
46256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46257       };
46258     } catch (...) {
46259       {
46260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46261       };
46262     }
46263   }
46264
46265   jresult = SWIG_csharp_string_callback((const char *)result);
46266   return jresult;
46267 }
46268
46269
46270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46271   unsigned int jresult ;
46272   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46273   bool result;
46274
46275   arg1 = (Dali::NativeImageInterface *)jarg1;
46276   {
46277     try {
46278       result = (bool)(arg1)->GlExtensionCreate();
46279     } catch (std::out_of_range& e) {
46280       {
46281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46282       };
46283     } catch (std::exception& e) {
46284       {
46285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46286       };
46287     } catch (Dali::DaliException e) {
46288       {
46289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46290       };
46291     } catch (...) {
46292       {
46293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46294       };
46295     }
46296   }
46297
46298   jresult = result;
46299   return jresult;
46300 }
46301
46302
46303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46304   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46305
46306   arg1 = (Dali::NativeImageInterface *)jarg1;
46307   {
46308     try {
46309       (arg1)->GlExtensionDestroy();
46310     } catch (std::out_of_range& e) {
46311       {
46312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46313       };
46314     } catch (std::exception& e) {
46315       {
46316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46317       };
46318     } catch (Dali::DaliException e) {
46319       {
46320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46321       };
46322     } catch (...) {
46323       {
46324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46325       };
46326     }
46327   }
46328
46329 }
46330
46331
46332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46333   unsigned int jresult ;
46334   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46335   unsigned int result;
46336
46337   arg1 = (Dali::NativeImageInterface *)jarg1;
46338   {
46339     try {
46340       result = (unsigned int)(arg1)->TargetTexture();
46341     } catch (std::out_of_range& e) {
46342       {
46343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46344       };
46345     } catch (std::exception& e) {
46346       {
46347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46348       };
46349     } catch (Dali::DaliException e) {
46350       {
46351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46352       };
46353     } catch (...) {
46354       {
46355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46356       };
46357     }
46358   }
46359
46360   jresult = result;
46361   return jresult;
46362 }
46363
46364
46365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46366   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46367
46368   arg1 = (Dali::NativeImageInterface *)jarg1;
46369   {
46370     try {
46371       (arg1)->PrepareTexture();
46372     } catch (std::out_of_range& e) {
46373       {
46374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46375       };
46376     } catch (std::exception& e) {
46377       {
46378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46379       };
46380     } catch (Dali::DaliException e) {
46381       {
46382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46383       };
46384     } catch (...) {
46385       {
46386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46387       };
46388     }
46389   }
46390
46391 }
46392
46393
46394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46395   unsigned int jresult ;
46396   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46397   unsigned int result;
46398
46399   arg1 = (Dali::NativeImageInterface *)jarg1;
46400   {
46401     try {
46402       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46403     } catch (std::out_of_range& e) {
46404       {
46405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46406       };
46407     } catch (std::exception& e) {
46408       {
46409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46410       };
46411     } catch (Dali::DaliException e) {
46412       {
46413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46414       };
46415     } catch (...) {
46416       {
46417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46418       };
46419     }
46420   }
46421
46422   jresult = result;
46423   return jresult;
46424 }
46425
46426
46427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46428   unsigned int jresult ;
46429   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46430   unsigned int result;
46431
46432   arg1 = (Dali::NativeImageInterface *)jarg1;
46433   {
46434     try {
46435       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46436     } catch (std::out_of_range& e) {
46437       {
46438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46439       };
46440     } catch (std::exception& e) {
46441       {
46442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46443       };
46444     } catch (Dali::DaliException e) {
46445       {
46446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46447       };
46448     } catch (...) {
46449       {
46450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46451       };
46452     }
46453   }
46454
46455   jresult = result;
46456   return jresult;
46457 }
46458
46459
46460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46461   unsigned int jresult ;
46462   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46463   bool result;
46464
46465   arg1 = (Dali::NativeImageInterface *)jarg1;
46466   {
46467     try {
46468       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46469     } catch (std::out_of_range& e) {
46470       {
46471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46472       };
46473     } catch (std::exception& e) {
46474       {
46475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46476       };
46477     } catch (Dali::DaliException e) {
46478       {
46479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46480       };
46481     } catch (...) {
46482       {
46483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46484       };
46485     }
46486   }
46487
46488   jresult = result;
46489   return jresult;
46490 }
46491
46492
46493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46494   void * jresult ;
46495   std::string *arg1 = 0 ;
46496   Dali::ImageDimensions result;
46497
46498   if (!jarg1) {
46499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46500     return 0;
46501   }
46502   std::string arg1_str(jarg1);
46503   arg1 = &arg1_str;
46504   {
46505     try {
46506       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
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 = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46527
46528   //argout typemap for const std::string&
46529
46530   return jresult;
46531 }
46532
46533
46534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46535   void * jresult ;
46536   Dali::ResourceImage *result = 0 ;
46537
46538   {
46539     try {
46540       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46541     } catch (std::out_of_range& e) {
46542       {
46543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46544       };
46545     } catch (std::exception& e) {
46546       {
46547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46548       };
46549     } catch (Dali::DaliException e) {
46550       {
46551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46552       };
46553     } catch (...) {
46554       {
46555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46556       };
46557     }
46558   }
46559
46560   jresult = (void *)result;
46561   return jresult;
46562 }
46563
46564
46565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46566   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46567
46568   arg1 = (Dali::ResourceImage *)jarg1;
46569   {
46570     try {
46571       delete arg1;
46572     } catch (std::out_of_range& e) {
46573       {
46574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46575       };
46576     } catch (std::exception& e) {
46577       {
46578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46579       };
46580     } catch (Dali::DaliException e) {
46581       {
46582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46583       };
46584     } catch (...) {
46585       {
46586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46587       };
46588     }
46589   }
46590
46591 }
46592
46593
46594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46595   void * jresult ;
46596   Dali::ResourceImage *arg1 = 0 ;
46597   Dali::ResourceImage *result = 0 ;
46598
46599   arg1 = (Dali::ResourceImage *)jarg1;
46600   if (!arg1) {
46601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46602     return 0;
46603   }
46604   {
46605     try {
46606       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46607     } catch (std::out_of_range& e) {
46608       {
46609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46610       };
46611     } catch (std::exception& e) {
46612       {
46613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46614       };
46615     } catch (Dali::DaliException e) {
46616       {
46617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46618       };
46619     } catch (...) {
46620       {
46621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46622       };
46623     }
46624   }
46625
46626   jresult = (void *)result;
46627   return jresult;
46628 }
46629
46630
46631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46632   void * jresult ;
46633   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46634   Dali::ResourceImage *arg2 = 0 ;
46635   Dali::ResourceImage *result = 0 ;
46636
46637   arg1 = (Dali::ResourceImage *)jarg1;
46638   arg2 = (Dali::ResourceImage *)jarg2;
46639   if (!arg2) {
46640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46641     return 0;
46642   }
46643   {
46644     try {
46645       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46646     } catch (std::out_of_range& e) {
46647       {
46648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46649       };
46650     } catch (std::exception& e) {
46651       {
46652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46653       };
46654     } catch (Dali::DaliException e) {
46655       {
46656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46657       };
46658     } catch (...) {
46659       {
46660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46661       };
46662     }
46663   }
46664
46665   jresult = (void *)result;
46666   return jresult;
46667 }
46668
46669
46670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46671   void * jresult ;
46672   std::string *arg1 = 0 ;
46673   bool arg2 ;
46674   Dali::ResourceImage result;
46675
46676   if (!jarg1) {
46677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46678     return 0;
46679   }
46680   std::string arg1_str(jarg1);
46681   arg1 = &arg1_str;
46682   arg2 = jarg2 ? true : false;
46683   {
46684     try {
46685       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46686     } catch (std::out_of_range& e) {
46687       {
46688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46689       };
46690     } catch (std::exception& e) {
46691       {
46692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46693       };
46694     } catch (Dali::DaliException e) {
46695       {
46696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46697       };
46698     } catch (...) {
46699       {
46700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46701       };
46702     }
46703   }
46704
46705   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46706
46707   //argout typemap for const std::string&
46708
46709   return jresult;
46710 }
46711
46712
46713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46714   void * jresult ;
46715   std::string *arg1 = 0 ;
46716   Dali::ResourceImage result;
46717
46718   if (!jarg1) {
46719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46720     return 0;
46721   }
46722   std::string arg1_str(jarg1);
46723   arg1 = &arg1_str;
46724   {
46725     try {
46726       result = Dali::ResourceImage::New((std::string const &)*arg1);
46727     } catch (std::out_of_range& e) {
46728       {
46729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46730       };
46731     } catch (std::exception& e) {
46732       {
46733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46734       };
46735     } catch (Dali::DaliException e) {
46736       {
46737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46738       };
46739     } catch (...) {
46740       {
46741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46742       };
46743     }
46744   }
46745
46746   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46747
46748   //argout typemap for const std::string&
46749
46750   return jresult;
46751 }
46752
46753
46754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46755   void * jresult ;
46756   std::string *arg1 = 0 ;
46757   Dali::ImageDimensions arg2 ;
46758   Dali::FittingMode::Type arg3 ;
46759   Dali::SamplingMode::Type arg4 ;
46760   bool arg5 ;
46761   Dali::ImageDimensions *argp2 ;
46762   Dali::ResourceImage result;
46763
46764   if (!jarg1) {
46765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46766     return 0;
46767   }
46768   std::string arg1_str(jarg1);
46769   arg1 = &arg1_str;
46770   argp2 = (Dali::ImageDimensions *)jarg2;
46771   if (!argp2) {
46772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46773     return 0;
46774   }
46775   arg2 = *argp2;
46776   arg3 = (Dali::FittingMode::Type)jarg3;
46777   arg4 = (Dali::SamplingMode::Type)jarg4;
46778   arg5 = jarg5 ? true : false;
46779   {
46780     try {
46781       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46782     } catch (std::out_of_range& e) {
46783       {
46784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46785       };
46786     } catch (std::exception& e) {
46787       {
46788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46789       };
46790     } catch (Dali::DaliException e) {
46791       {
46792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46793       };
46794     } catch (...) {
46795       {
46796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46797       };
46798     }
46799   }
46800
46801   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46802
46803   //argout typemap for const std::string&
46804
46805   return jresult;
46806 }
46807
46808
46809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46810   void * jresult ;
46811   std::string *arg1 = 0 ;
46812   Dali::ImageDimensions arg2 ;
46813   Dali::FittingMode::Type arg3 ;
46814   Dali::SamplingMode::Type arg4 ;
46815   Dali::ImageDimensions *argp2 ;
46816   Dali::ResourceImage result;
46817
46818   if (!jarg1) {
46819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46820     return 0;
46821   }
46822   std::string arg1_str(jarg1);
46823   arg1 = &arg1_str;
46824   argp2 = (Dali::ImageDimensions *)jarg2;
46825   if (!argp2) {
46826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46827     return 0;
46828   }
46829   arg2 = *argp2;
46830   arg3 = (Dali::FittingMode::Type)jarg3;
46831   arg4 = (Dali::SamplingMode::Type)jarg4;
46832   {
46833     try {
46834       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46835     } catch (std::out_of_range& e) {
46836       {
46837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46838       };
46839     } catch (std::exception& e) {
46840       {
46841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46842       };
46843     } catch (Dali::DaliException e) {
46844       {
46845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46846       };
46847     } catch (...) {
46848       {
46849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46850       };
46851     }
46852   }
46853
46854   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46855
46856   //argout typemap for const std::string&
46857
46858   return jresult;
46859 }
46860
46861
46862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46863   void * jresult ;
46864   std::string *arg1 = 0 ;
46865   Dali::ImageDimensions arg2 ;
46866   Dali::FittingMode::Type arg3 ;
46867   Dali::ImageDimensions *argp2 ;
46868   Dali::ResourceImage result;
46869
46870   if (!jarg1) {
46871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46872     return 0;
46873   }
46874   std::string arg1_str(jarg1);
46875   arg1 = &arg1_str;
46876   argp2 = (Dali::ImageDimensions *)jarg2;
46877   if (!argp2) {
46878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46879     return 0;
46880   }
46881   arg2 = *argp2;
46882   arg3 = (Dali::FittingMode::Type)jarg3;
46883   {
46884     try {
46885       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46886     } catch (std::out_of_range& e) {
46887       {
46888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46889       };
46890     } catch (std::exception& e) {
46891       {
46892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46893       };
46894     } catch (Dali::DaliException e) {
46895       {
46896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46897       };
46898     } catch (...) {
46899       {
46900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46901       };
46902     }
46903   }
46904
46905   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46906
46907   //argout typemap for const std::string&
46908
46909   return jresult;
46910 }
46911
46912
46913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46914   void * jresult ;
46915   std::string *arg1 = 0 ;
46916   Dali::ImageDimensions arg2 ;
46917   Dali::ImageDimensions *argp2 ;
46918   Dali::ResourceImage result;
46919
46920   if (!jarg1) {
46921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46922     return 0;
46923   }
46924   std::string arg1_str(jarg1);
46925   arg1 = &arg1_str;
46926   argp2 = (Dali::ImageDimensions *)jarg2;
46927   if (!argp2) {
46928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46929     return 0;
46930   }
46931   arg2 = *argp2;
46932   {
46933     try {
46934       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46935     } catch (std::out_of_range& e) {
46936       {
46937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46938       };
46939     } catch (std::exception& e) {
46940       {
46941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46942       };
46943     } catch (Dali::DaliException e) {
46944       {
46945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46946       };
46947     } catch (...) {
46948       {
46949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46950       };
46951     }
46952   }
46953
46954   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46955
46956   //argout typemap for const std::string&
46957
46958   return jresult;
46959 }
46960
46961
46962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46963   void * jresult ;
46964   Dali::BaseHandle arg1 ;
46965   Dali::BaseHandle *argp1 ;
46966   Dali::ResourceImage result;
46967
46968   argp1 = (Dali::BaseHandle *)jarg1;
46969   if (!argp1) {
46970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46971     return 0;
46972   }
46973   arg1 = *argp1;
46974   {
46975     try {
46976       result = Dali::ResourceImage::DownCast(arg1);
46977     } catch (std::out_of_range& e) {
46978       {
46979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46980       };
46981     } catch (std::exception& e) {
46982       {
46983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46984       };
46985     } catch (Dali::DaliException e) {
46986       {
46987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46988       };
46989     } catch (...) {
46990       {
46991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46992       };
46993     }
46994   }
46995
46996   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46997   return jresult;
46998 }
46999
47000
47001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47002   int jresult ;
47003   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47004   Dali::LoadingState result;
47005
47006   arg1 = (Dali::ResourceImage *)jarg1;
47007   {
47008     try {
47009       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47010     } catch (std::out_of_range& e) {
47011       {
47012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47013       };
47014     } catch (std::exception& e) {
47015       {
47016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47017       };
47018     } catch (Dali::DaliException e) {
47019       {
47020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47021       };
47022     } catch (...) {
47023       {
47024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47025       };
47026     }
47027   }
47028
47029   jresult = (int)result;
47030   return jresult;
47031 }
47032
47033
47034 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47035   char * jresult ;
47036   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47037   std::string result;
47038
47039   arg1 = (Dali::ResourceImage *)jarg1;
47040   {
47041     try {
47042       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47043     } catch (std::out_of_range& e) {
47044       {
47045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47046       };
47047     } catch (std::exception& e) {
47048       {
47049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47050       };
47051     } catch (Dali::DaliException e) {
47052       {
47053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47054       };
47055     } catch (...) {
47056       {
47057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47058       };
47059     }
47060   }
47061
47062   jresult = SWIG_csharp_string_callback((&result)->c_str());
47063   return jresult;
47064 }
47065
47066
47067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47068   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47069
47070   arg1 = (Dali::ResourceImage *)jarg1;
47071   {
47072     try {
47073       (arg1)->Reload();
47074     } catch (std::out_of_range& e) {
47075       {
47076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47077       };
47078     } catch (std::exception& e) {
47079       {
47080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47081       };
47082     } catch (Dali::DaliException e) {
47083       {
47084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47085       };
47086     } catch (...) {
47087       {
47088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47089       };
47090     }
47091   }
47092
47093 }
47094
47095
47096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47097   void * jresult ;
47098   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47099   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47100
47101   arg1 = (Dali::ResourceImage *)jarg1;
47102   {
47103     try {
47104       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47105     } catch (std::out_of_range& e) {
47106       {
47107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47108       };
47109     } catch (std::exception& e) {
47110       {
47111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47112       };
47113     } catch (Dali::DaliException e) {
47114       {
47115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47116       };
47117     } catch (...) {
47118       {
47119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47120       };
47121     }
47122   }
47123
47124   jresult = (void *)result;
47125   return jresult;
47126 }
47127
47128
47129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47130   void * jresult ;
47131   Dali::FrameBufferImage *result = 0 ;
47132
47133   {
47134     try {
47135       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47136     } catch (std::out_of_range& e) {
47137       {
47138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47139       };
47140     } catch (std::exception& e) {
47141       {
47142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47143       };
47144     } catch (Dali::DaliException e) {
47145       {
47146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47147       };
47148     } catch (...) {
47149       {
47150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47151       };
47152     }
47153   }
47154
47155   jresult = (void *)result;
47156   return jresult;
47157 }
47158
47159
47160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47161   void * jresult ;
47162   unsigned int arg1 ;
47163   unsigned int arg2 ;
47164   Dali::Pixel::Format arg3 ;
47165   Dali::RenderBuffer::Format arg4 ;
47166   Dali::FrameBufferImage result;
47167
47168   arg1 = (unsigned int)jarg1;
47169   arg2 = (unsigned int)jarg2;
47170   arg3 = (Dali::Pixel::Format)jarg3;
47171   arg4 = (Dali::RenderBuffer::Format)jarg4;
47172   {
47173     try {
47174       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47175     } catch (std::out_of_range& e) {
47176       {
47177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47178       };
47179     } catch (std::exception& e) {
47180       {
47181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47182       };
47183     } catch (Dali::DaliException e) {
47184       {
47185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47186       };
47187     } catch (...) {
47188       {
47189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47190       };
47191     }
47192   }
47193
47194   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47195   return jresult;
47196 }
47197
47198
47199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47200   void * jresult ;
47201   unsigned int arg1 ;
47202   unsigned int arg2 ;
47203   Dali::Pixel::Format arg3 ;
47204   Dali::FrameBufferImage result;
47205
47206   arg1 = (unsigned int)jarg1;
47207   arg2 = (unsigned int)jarg2;
47208   arg3 = (Dali::Pixel::Format)jarg3;
47209   {
47210     try {
47211       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47212     } catch (std::out_of_range& e) {
47213       {
47214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47215       };
47216     } catch (std::exception& e) {
47217       {
47218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47219       };
47220     } catch (Dali::DaliException e) {
47221       {
47222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47223       };
47224     } catch (...) {
47225       {
47226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47227       };
47228     }
47229   }
47230
47231   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47232   return jresult;
47233 }
47234
47235
47236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47237   void * jresult ;
47238   unsigned int arg1 ;
47239   unsigned int arg2 ;
47240   Dali::FrameBufferImage result;
47241
47242   arg1 = (unsigned int)jarg1;
47243   arg2 = (unsigned int)jarg2;
47244   {
47245     try {
47246       result = Dali::FrameBufferImage::New(arg1,arg2);
47247     } catch (std::out_of_range& e) {
47248       {
47249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47250       };
47251     } catch (std::exception& e) {
47252       {
47253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47254       };
47255     } catch (Dali::DaliException e) {
47256       {
47257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47258       };
47259     } catch (...) {
47260       {
47261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47262       };
47263     }
47264   }
47265
47266   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47267   return jresult;
47268 }
47269
47270
47271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47272   void * jresult ;
47273   unsigned int arg1 ;
47274   Dali::FrameBufferImage result;
47275
47276   arg1 = (unsigned int)jarg1;
47277   {
47278     try {
47279       result = Dali::FrameBufferImage::New(arg1);
47280     } catch (std::out_of_range& e) {
47281       {
47282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47283       };
47284     } catch (std::exception& e) {
47285       {
47286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47287       };
47288     } catch (Dali::DaliException e) {
47289       {
47290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47291       };
47292     } catch (...) {
47293       {
47294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47295       };
47296     }
47297   }
47298
47299   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47300   return jresult;
47301 }
47302
47303
47304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47305   void * jresult ;
47306   Dali::FrameBufferImage result;
47307
47308   {
47309     try {
47310       result = Dali::FrameBufferImage::New();
47311     } catch (std::out_of_range& e) {
47312       {
47313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47314       };
47315     } catch (std::exception& e) {
47316       {
47317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47318       };
47319     } catch (Dali::DaliException e) {
47320       {
47321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47322       };
47323     } catch (...) {
47324       {
47325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47326       };
47327     }
47328   }
47329
47330   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47331   return jresult;
47332 }
47333
47334
47335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47336   void * jresult ;
47337   Dali::NativeImageInterface *arg1 = 0 ;
47338   Dali::FrameBufferImage result;
47339
47340   arg1 = (Dali::NativeImageInterface *)jarg1;
47341   if (!arg1) {
47342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47343     return 0;
47344   }
47345   {
47346     try {
47347       result = Dali::FrameBufferImage::New(*arg1);
47348     } catch (std::out_of_range& e) {
47349       {
47350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47351       };
47352     } catch (std::exception& e) {
47353       {
47354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47355       };
47356     } catch (Dali::DaliException e) {
47357       {
47358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47359       };
47360     } catch (...) {
47361       {
47362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47363       };
47364     }
47365   }
47366
47367   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47368   return jresult;
47369 }
47370
47371
47372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47373   void * jresult ;
47374   Dali::BaseHandle arg1 ;
47375   Dali::BaseHandle *argp1 ;
47376   Dali::FrameBufferImage result;
47377
47378   argp1 = (Dali::BaseHandle *)jarg1;
47379   if (!argp1) {
47380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47381     return 0;
47382   }
47383   arg1 = *argp1;
47384   {
47385     try {
47386       result = Dali::FrameBufferImage::DownCast(arg1);
47387     } catch (std::out_of_range& e) {
47388       {
47389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47390       };
47391     } catch (std::exception& e) {
47392       {
47393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47394       };
47395     } catch (Dali::DaliException e) {
47396       {
47397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47398       };
47399     } catch (...) {
47400       {
47401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47402       };
47403     }
47404   }
47405
47406   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47407   return jresult;
47408 }
47409
47410
47411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47412   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47413
47414   arg1 = (Dali::FrameBufferImage *)jarg1;
47415   {
47416     try {
47417       delete arg1;
47418     } catch (std::out_of_range& e) {
47419       {
47420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47421       };
47422     } catch (std::exception& e) {
47423       {
47424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47425       };
47426     } catch (Dali::DaliException e) {
47427       {
47428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47429       };
47430     } catch (...) {
47431       {
47432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47433       };
47434     }
47435   }
47436
47437 }
47438
47439
47440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47441   void * jresult ;
47442   Dali::FrameBufferImage *arg1 = 0 ;
47443   Dali::FrameBufferImage *result = 0 ;
47444
47445   arg1 = (Dali::FrameBufferImage *)jarg1;
47446   if (!arg1) {
47447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47448     return 0;
47449   }
47450   {
47451     try {
47452       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47453     } catch (std::out_of_range& e) {
47454       {
47455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47456       };
47457     } catch (std::exception& e) {
47458       {
47459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47460       };
47461     } catch (Dali::DaliException e) {
47462       {
47463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47464       };
47465     } catch (...) {
47466       {
47467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47468       };
47469     }
47470   }
47471
47472   jresult = (void *)result;
47473   return jresult;
47474 }
47475
47476
47477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47478   void * jresult ;
47479   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47480   Dali::FrameBufferImage *arg2 = 0 ;
47481   Dali::FrameBufferImage *result = 0 ;
47482
47483   arg1 = (Dali::FrameBufferImage *)jarg1;
47484   arg2 = (Dali::FrameBufferImage *)jarg2;
47485   if (!arg2) {
47486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47487     return 0;
47488   }
47489   {
47490     try {
47491       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47492     } catch (std::out_of_range& e) {
47493       {
47494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47495       };
47496     } catch (std::exception& e) {
47497       {
47498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47499       };
47500     } catch (Dali::DaliException e) {
47501       {
47502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47503       };
47504     } catch (...) {
47505       {
47506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47507       };
47508     }
47509   }
47510
47511   jresult = (void *)result;
47512   return jresult;
47513 }
47514
47515
47516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47517   void * jresult ;
47518   Dali::NinePatchImage *result = 0 ;
47519
47520   {
47521     try {
47522       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47523     } catch (std::out_of_range& e) {
47524       {
47525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47526       };
47527     } catch (std::exception& e) {
47528       {
47529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47530       };
47531     } catch (Dali::DaliException e) {
47532       {
47533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47534       };
47535     } catch (...) {
47536       {
47537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47538       };
47539     }
47540   }
47541
47542   jresult = (void *)result;
47543   return jresult;
47544 }
47545
47546
47547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47548   void * jresult ;
47549   std::string *arg1 = 0 ;
47550   Dali::NinePatchImage result;
47551
47552   if (!jarg1) {
47553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47554     return 0;
47555   }
47556   std::string arg1_str(jarg1);
47557   arg1 = &arg1_str;
47558   {
47559     try {
47560       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47561     } catch (std::out_of_range& e) {
47562       {
47563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47564       };
47565     } catch (std::exception& e) {
47566       {
47567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47568       };
47569     } catch (Dali::DaliException e) {
47570       {
47571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47572       };
47573     } catch (...) {
47574       {
47575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47576       };
47577     }
47578   }
47579
47580   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47581
47582   //argout typemap for const std::string&
47583
47584   return jresult;
47585 }
47586
47587
47588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47589   void * jresult ;
47590   Dali::BaseHandle arg1 ;
47591   Dali::BaseHandle *argp1 ;
47592   Dali::NinePatchImage result;
47593
47594   argp1 = (Dali::BaseHandle *)jarg1;
47595   if (!argp1) {
47596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47597     return 0;
47598   }
47599   arg1 = *argp1;
47600   {
47601     try {
47602       result = Dali::NinePatchImage::DownCast(arg1);
47603     } catch (std::out_of_range& e) {
47604       {
47605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47606       };
47607     } catch (std::exception& e) {
47608       {
47609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47610       };
47611     } catch (Dali::DaliException e) {
47612       {
47613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47614       };
47615     } catch (...) {
47616       {
47617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47618       };
47619     }
47620   }
47621
47622   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47623   return jresult;
47624 }
47625
47626
47627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47628   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47629
47630   arg1 = (Dali::NinePatchImage *)jarg1;
47631   {
47632     try {
47633       delete arg1;
47634     } catch (std::out_of_range& e) {
47635       {
47636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47637       };
47638     } catch (std::exception& e) {
47639       {
47640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47641       };
47642     } catch (Dali::DaliException e) {
47643       {
47644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47645       };
47646     } catch (...) {
47647       {
47648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47649       };
47650     }
47651   }
47652
47653 }
47654
47655
47656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47657   void * jresult ;
47658   Dali::NinePatchImage *arg1 = 0 ;
47659   Dali::NinePatchImage *result = 0 ;
47660
47661   arg1 = (Dali::NinePatchImage *)jarg1;
47662   if (!arg1) {
47663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47664     return 0;
47665   }
47666   {
47667     try {
47668       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47669     } catch (std::out_of_range& e) {
47670       {
47671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47672       };
47673     } catch (std::exception& e) {
47674       {
47675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47676       };
47677     } catch (Dali::DaliException e) {
47678       {
47679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47680       };
47681     } catch (...) {
47682       {
47683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47684       };
47685     }
47686   }
47687
47688   jresult = (void *)result;
47689   return jresult;
47690 }
47691
47692
47693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47694   void * jresult ;
47695   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47696   Dali::NinePatchImage *arg2 = 0 ;
47697   Dali::NinePatchImage *result = 0 ;
47698
47699   arg1 = (Dali::NinePatchImage *)jarg1;
47700   arg2 = (Dali::NinePatchImage *)jarg2;
47701   if (!arg2) {
47702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47703     return 0;
47704   }
47705   {
47706     try {
47707       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47708     } catch (std::out_of_range& e) {
47709       {
47710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47711       };
47712     } catch (std::exception& e) {
47713       {
47714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47715       };
47716     } catch (Dali::DaliException e) {
47717       {
47718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47719       };
47720     } catch (...) {
47721       {
47722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47723       };
47724     }
47725   }
47726
47727   jresult = (void *)result;
47728   return jresult;
47729 }
47730
47731
47732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47733   void * jresult ;
47734   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47735   Dali::Vector4 result;
47736
47737   arg1 = (Dali::NinePatchImage *)jarg1;
47738   {
47739     try {
47740       result = (arg1)->GetStretchBorders();
47741     } catch (std::out_of_range& e) {
47742       {
47743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47744       };
47745     } catch (std::exception& e) {
47746       {
47747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47748       };
47749     } catch (Dali::DaliException e) {
47750       {
47751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47752       };
47753     } catch (...) {
47754       {
47755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47756       };
47757     }
47758   }
47759
47760   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47761   return jresult;
47762 }
47763
47764
47765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47766   void * jresult ;
47767   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47768   Dali::NinePatchImage::StretchRanges *result = 0 ;
47769
47770   arg1 = (Dali::NinePatchImage *)jarg1;
47771   {
47772     try {
47773       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47774     } catch (std::out_of_range& e) {
47775       {
47776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47777       };
47778     } catch (std::exception& e) {
47779       {
47780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47781       };
47782     } catch (Dali::DaliException e) {
47783       {
47784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47785       };
47786     } catch (...) {
47787       {
47788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47789       };
47790     }
47791   }
47792
47793   jresult = (void *)result;
47794   return jresult;
47795 }
47796
47797
47798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47799   void * jresult ;
47800   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47801   Dali::NinePatchImage::StretchRanges *result = 0 ;
47802
47803   arg1 = (Dali::NinePatchImage *)jarg1;
47804   {
47805     try {
47806       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47807     } catch (std::out_of_range& e) {
47808       {
47809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47810       };
47811     } catch (std::exception& e) {
47812       {
47813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47814       };
47815     } catch (Dali::DaliException e) {
47816       {
47817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47818       };
47819     } catch (...) {
47820       {
47821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47822       };
47823     }
47824   }
47825
47826   jresult = (void *)result;
47827   return jresult;
47828 }
47829
47830
47831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47832   void * jresult ;
47833   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47834   Dali::Rect< int > result;
47835
47836   arg1 = (Dali::NinePatchImage *)jarg1;
47837   {
47838     try {
47839       result = (arg1)->GetChildRectangle();
47840     } catch (std::out_of_range& e) {
47841       {
47842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47843       };
47844     } catch (std::exception& e) {
47845       {
47846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47847       };
47848     } catch (Dali::DaliException e) {
47849       {
47850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47851       };
47852     } catch (...) {
47853       {
47854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47855       };
47856     }
47857   }
47858
47859   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47860   return jresult;
47861 }
47862
47863
47864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47865   void * jresult ;
47866   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47867   Dali::BufferImage result;
47868
47869   arg1 = (Dali::NinePatchImage *)jarg1;
47870   {
47871     try {
47872       result = (arg1)->CreateCroppedBufferImage();
47873     } catch (std::out_of_range& e) {
47874       {
47875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47876       };
47877     } catch (std::exception& e) {
47878       {
47879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47880       };
47881     } catch (Dali::DaliException e) {
47882       {
47883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47884       };
47885     } catch (...) {
47886       {
47887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47888       };
47889     }
47890   }
47891
47892   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47893   return jresult;
47894 }
47895
47896
47897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47898   unsigned int jresult ;
47899   std::string *arg1 = 0 ;
47900   bool result;
47901
47902   if (!jarg1) {
47903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47904     return 0;
47905   }
47906   std::string arg1_str(jarg1);
47907   arg1 = &arg1_str;
47908   {
47909     try {
47910       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47911     } catch (std::out_of_range& e) {
47912       {
47913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47914       };
47915     } catch (std::exception& e) {
47916       {
47917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47918       };
47919     } catch (Dali::DaliException e) {
47920       {
47921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47922       };
47923     } catch (...) {
47924       {
47925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47926       };
47927     }
47928   }
47929
47930   jresult = result;
47931
47932   //argout typemap for const std::string&
47933
47934   return jresult;
47935 }
47936
47937
47938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47939   int jresult ;
47940   int result;
47941
47942   result = (int)Dali::CameraActor::Property::TYPE;
47943   jresult = (int)result;
47944   return jresult;
47945 }
47946
47947
47948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47949   int jresult ;
47950   int result;
47951
47952   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47953   jresult = (int)result;
47954   return jresult;
47955 }
47956
47957
47958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47959   int jresult ;
47960   int result;
47961
47962   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47963   jresult = (int)result;
47964   return jresult;
47965 }
47966
47967
47968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47969   int jresult ;
47970   int result;
47971
47972   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47973   jresult = (int)result;
47974   return jresult;
47975 }
47976
47977
47978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47979   int jresult ;
47980   int result;
47981
47982   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47983   jresult = (int)result;
47984   return jresult;
47985 }
47986
47987
47988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47989   int jresult ;
47990   int result;
47991
47992   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47993   jresult = (int)result;
47994   return jresult;
47995 }
47996
47997
47998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47999   int jresult ;
48000   int result;
48001
48002   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48003   jresult = (int)result;
48004   return jresult;
48005 }
48006
48007
48008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48009   int jresult ;
48010   int result;
48011
48012   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48013   jresult = (int)result;
48014   return jresult;
48015 }
48016
48017
48018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48019   int jresult ;
48020   int result;
48021
48022   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48023   jresult = (int)result;
48024   return jresult;
48025 }
48026
48027
48028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48029   int jresult ;
48030   int result;
48031
48032   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48033   jresult = (int)result;
48034   return jresult;
48035 }
48036
48037
48038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48039   int jresult ;
48040   int result;
48041
48042   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48043   jresult = (int)result;
48044   return jresult;
48045 }
48046
48047
48048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48049   int jresult ;
48050   int result;
48051
48052   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48053   jresult = (int)result;
48054   return jresult;
48055 }
48056
48057
48058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48059   int jresult ;
48060   int result;
48061
48062   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48063   jresult = (int)result;
48064   return jresult;
48065 }
48066
48067
48068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48069   int jresult ;
48070   int result;
48071
48072   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48073   jresult = (int)result;
48074   return jresult;
48075 }
48076
48077
48078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48079   void * jresult ;
48080   Dali::CameraActor::Property *result = 0 ;
48081
48082   {
48083     try {
48084       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48085     } catch (std::out_of_range& e) {
48086       {
48087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48088       };
48089     } catch (std::exception& e) {
48090       {
48091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48092       };
48093     } catch (Dali::DaliException e) {
48094       {
48095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48096       };
48097     } catch (...) {
48098       {
48099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48100       };
48101     }
48102   }
48103
48104   jresult = (void *)result;
48105   return jresult;
48106 }
48107
48108
48109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48110   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48111
48112   arg1 = (Dali::CameraActor::Property *)jarg1;
48113   {
48114     try {
48115       delete arg1;
48116     } catch (std::out_of_range& e) {
48117       {
48118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48119       };
48120     } catch (std::exception& e) {
48121       {
48122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48123       };
48124     } catch (Dali::DaliException e) {
48125       {
48126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48127       };
48128     } catch (...) {
48129       {
48130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48131       };
48132     }
48133   }
48134
48135 }
48136
48137
48138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48139   void * jresult ;
48140   Dali::CameraActor *result = 0 ;
48141
48142   {
48143     try {
48144       result = (Dali::CameraActor *)new Dali::CameraActor();
48145     } catch (std::out_of_range& e) {
48146       {
48147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48148       };
48149     } catch (std::exception& e) {
48150       {
48151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48152       };
48153     } catch (Dali::DaliException e) {
48154       {
48155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48156       };
48157     } catch (...) {
48158       {
48159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48160       };
48161     }
48162   }
48163
48164   jresult = (void *)result;
48165   return jresult;
48166 }
48167
48168
48169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48170   void * jresult ;
48171   Dali::CameraActor result;
48172
48173   {
48174     try {
48175       result = Dali::CameraActor::New();
48176     } catch (std::out_of_range& e) {
48177       {
48178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48179       };
48180     } catch (std::exception& e) {
48181       {
48182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48183       };
48184     } catch (Dali::DaliException e) {
48185       {
48186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48187       };
48188     } catch (...) {
48189       {
48190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48191       };
48192     }
48193   }
48194
48195   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48196   return jresult;
48197 }
48198
48199
48200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48201   void * jresult ;
48202   Dali::Size *arg1 = 0 ;
48203   Dali::CameraActor result;
48204
48205   arg1 = (Dali::Size *)jarg1;
48206   if (!arg1) {
48207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48208     return 0;
48209   }
48210   {
48211     try {
48212       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48213     } catch (std::out_of_range& e) {
48214       {
48215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48216       };
48217     } catch (std::exception& e) {
48218       {
48219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48220       };
48221     } catch (Dali::DaliException e) {
48222       {
48223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48224       };
48225     } catch (...) {
48226       {
48227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48228       };
48229     }
48230   }
48231
48232   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48233   return jresult;
48234 }
48235
48236
48237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48238   void * jresult ;
48239   Dali::BaseHandle arg1 ;
48240   Dali::BaseHandle *argp1 ;
48241   Dali::CameraActor result;
48242
48243   argp1 = (Dali::BaseHandle *)jarg1;
48244   if (!argp1) {
48245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48246     return 0;
48247   }
48248   arg1 = *argp1;
48249   {
48250     try {
48251       result = Dali::CameraActor::DownCast(arg1);
48252     } catch (std::out_of_range& e) {
48253       {
48254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48255       };
48256     } catch (std::exception& e) {
48257       {
48258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48259       };
48260     } catch (Dali::DaliException e) {
48261       {
48262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48263       };
48264     } catch (...) {
48265       {
48266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48267       };
48268     }
48269   }
48270
48271   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48272   return jresult;
48273 }
48274
48275
48276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48277   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48278
48279   arg1 = (Dali::CameraActor *)jarg1;
48280   {
48281     try {
48282       delete arg1;
48283     } catch (std::out_of_range& e) {
48284       {
48285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48286       };
48287     } catch (std::exception& e) {
48288       {
48289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48290       };
48291     } catch (Dali::DaliException e) {
48292       {
48293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48294       };
48295     } catch (...) {
48296       {
48297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48298       };
48299     }
48300   }
48301
48302 }
48303
48304
48305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48306   void * jresult ;
48307   Dali::CameraActor *arg1 = 0 ;
48308   Dali::CameraActor *result = 0 ;
48309
48310   arg1 = (Dali::CameraActor *)jarg1;
48311   if (!arg1) {
48312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48313     return 0;
48314   }
48315   {
48316     try {
48317       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48318     } catch (std::out_of_range& e) {
48319       {
48320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48321       };
48322     } catch (std::exception& e) {
48323       {
48324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48325       };
48326     } catch (Dali::DaliException e) {
48327       {
48328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48329       };
48330     } catch (...) {
48331       {
48332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48333       };
48334     }
48335   }
48336
48337   jresult = (void *)result;
48338   return jresult;
48339 }
48340
48341
48342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48343   void * jresult ;
48344   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48345   Dali::CameraActor *arg2 = 0 ;
48346   Dali::CameraActor *result = 0 ;
48347
48348   arg1 = (Dali::CameraActor *)jarg1;
48349   arg2 = (Dali::CameraActor *)jarg2;
48350   if (!arg2) {
48351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48352     return 0;
48353   }
48354   {
48355     try {
48356       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48357     } catch (std::out_of_range& e) {
48358       {
48359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48360       };
48361     } catch (std::exception& e) {
48362       {
48363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48364       };
48365     } catch (Dali::DaliException e) {
48366       {
48367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48368       };
48369     } catch (...) {
48370       {
48371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48372       };
48373     }
48374   }
48375
48376   jresult = (void *)result;
48377   return jresult;
48378 }
48379
48380
48381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48382   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48383   Dali::Camera::Type arg2 ;
48384
48385   arg1 = (Dali::CameraActor *)jarg1;
48386   arg2 = (Dali::Camera::Type)jarg2;
48387   {
48388     try {
48389       (arg1)->SetType(arg2);
48390     } catch (std::out_of_range& e) {
48391       {
48392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48393       };
48394     } catch (std::exception& e) {
48395       {
48396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48397       };
48398     } catch (Dali::DaliException e) {
48399       {
48400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48401       };
48402     } catch (...) {
48403       {
48404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48405       };
48406     }
48407   }
48408
48409 }
48410
48411
48412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48413   int jresult ;
48414   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48415   Dali::Camera::Type result;
48416
48417   arg1 = (Dali::CameraActor *)jarg1;
48418   {
48419     try {
48420       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48421     } catch (std::out_of_range& e) {
48422       {
48423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48424       };
48425     } catch (std::exception& e) {
48426       {
48427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48428       };
48429     } catch (Dali::DaliException e) {
48430       {
48431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48432       };
48433     } catch (...) {
48434       {
48435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48436       };
48437     }
48438   }
48439
48440   jresult = (int)result;
48441   return jresult;
48442 }
48443
48444
48445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48446   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48447   Dali::Camera::ProjectionMode arg2 ;
48448
48449   arg1 = (Dali::CameraActor *)jarg1;
48450   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48451   {
48452     try {
48453       (arg1)->SetProjectionMode(arg2);
48454     } catch (std::out_of_range& e) {
48455       {
48456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48457       };
48458     } catch (std::exception& e) {
48459       {
48460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48461       };
48462     } catch (Dali::DaliException e) {
48463       {
48464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48465       };
48466     } catch (...) {
48467       {
48468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48469       };
48470     }
48471   }
48472
48473 }
48474
48475
48476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48477   int jresult ;
48478   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48479   Dali::Camera::ProjectionMode result;
48480
48481   arg1 = (Dali::CameraActor *)jarg1;
48482   {
48483     try {
48484       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48485     } catch (std::out_of_range& e) {
48486       {
48487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48488       };
48489     } catch (std::exception& e) {
48490       {
48491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48492       };
48493     } catch (Dali::DaliException e) {
48494       {
48495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48496       };
48497     } catch (...) {
48498       {
48499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48500       };
48501     }
48502   }
48503
48504   jresult = (int)result;
48505   return jresult;
48506 }
48507
48508
48509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48510   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48511   float arg2 ;
48512
48513   arg1 = (Dali::CameraActor *)jarg1;
48514   arg2 = (float)jarg2;
48515   {
48516     try {
48517       (arg1)->SetFieldOfView(arg2);
48518     } catch (std::out_of_range& e) {
48519       {
48520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48521       };
48522     } catch (std::exception& e) {
48523       {
48524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48525       };
48526     } catch (Dali::DaliException e) {
48527       {
48528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48529       };
48530     } catch (...) {
48531       {
48532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48533       };
48534     }
48535   }
48536
48537 }
48538
48539
48540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48541   float jresult ;
48542   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48543   float result;
48544
48545   arg1 = (Dali::CameraActor *)jarg1;
48546   {
48547     try {
48548       result = (float)(arg1)->GetFieldOfView();
48549     } catch (std::out_of_range& e) {
48550       {
48551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48552       };
48553     } catch (std::exception& e) {
48554       {
48555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48556       };
48557     } catch (Dali::DaliException e) {
48558       {
48559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48560       };
48561     } catch (...) {
48562       {
48563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48564       };
48565     }
48566   }
48567
48568   jresult = result;
48569   return jresult;
48570 }
48571
48572
48573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48574   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48575   float arg2 ;
48576
48577   arg1 = (Dali::CameraActor *)jarg1;
48578   arg2 = (float)jarg2;
48579   {
48580     try {
48581       (arg1)->SetAspectRatio(arg2);
48582     } catch (std::out_of_range& e) {
48583       {
48584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48585       };
48586     } catch (std::exception& e) {
48587       {
48588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48589       };
48590     } catch (Dali::DaliException e) {
48591       {
48592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48593       };
48594     } catch (...) {
48595       {
48596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48597       };
48598     }
48599   }
48600
48601 }
48602
48603
48604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48605   float jresult ;
48606   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48607   float result;
48608
48609   arg1 = (Dali::CameraActor *)jarg1;
48610   {
48611     try {
48612       result = (float)(arg1)->GetAspectRatio();
48613     } catch (std::out_of_range& e) {
48614       {
48615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48616       };
48617     } catch (std::exception& e) {
48618       {
48619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48620       };
48621     } catch (Dali::DaliException e) {
48622       {
48623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48624       };
48625     } catch (...) {
48626       {
48627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48628       };
48629     }
48630   }
48631
48632   jresult = result;
48633   return jresult;
48634 }
48635
48636
48637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48638   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48639   float arg2 ;
48640
48641   arg1 = (Dali::CameraActor *)jarg1;
48642   arg2 = (float)jarg2;
48643   {
48644     try {
48645       (arg1)->SetNearClippingPlane(arg2);
48646     } catch (std::out_of_range& e) {
48647       {
48648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48649       };
48650     } catch (std::exception& e) {
48651       {
48652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48653       };
48654     } catch (Dali::DaliException e) {
48655       {
48656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48657       };
48658     } catch (...) {
48659       {
48660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48661       };
48662     }
48663   }
48664
48665 }
48666
48667
48668 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48669   float jresult ;
48670   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48671   float result;
48672
48673   arg1 = (Dali::CameraActor *)jarg1;
48674   {
48675     try {
48676       result = (float)(arg1)->GetNearClippingPlane();
48677     } catch (std::out_of_range& e) {
48678       {
48679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48680       };
48681     } catch (std::exception& e) {
48682       {
48683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48684       };
48685     } catch (Dali::DaliException e) {
48686       {
48687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48688       };
48689     } catch (...) {
48690       {
48691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48692       };
48693     }
48694   }
48695
48696   jresult = result;
48697   return jresult;
48698 }
48699
48700
48701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48702   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48703   float arg2 ;
48704
48705   arg1 = (Dali::CameraActor *)jarg1;
48706   arg2 = (float)jarg2;
48707   {
48708     try {
48709       (arg1)->SetFarClippingPlane(arg2);
48710     } catch (std::out_of_range& e) {
48711       {
48712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48713       };
48714     } catch (std::exception& e) {
48715       {
48716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48717       };
48718     } catch (Dali::DaliException e) {
48719       {
48720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48721       };
48722     } catch (...) {
48723       {
48724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48725       };
48726     }
48727   }
48728
48729 }
48730
48731
48732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48733   float jresult ;
48734   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48735   float result;
48736
48737   arg1 = (Dali::CameraActor *)jarg1;
48738   {
48739     try {
48740       result = (float)(arg1)->GetFarClippingPlane();
48741     } catch (std::out_of_range& e) {
48742       {
48743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48744       };
48745     } catch (std::exception& e) {
48746       {
48747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48748       };
48749     } catch (Dali::DaliException e) {
48750       {
48751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48752       };
48753     } catch (...) {
48754       {
48755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48756       };
48757     }
48758   }
48759
48760   jresult = result;
48761   return jresult;
48762 }
48763
48764
48765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48766   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48767   Dali::Vector3 *arg2 = 0 ;
48768
48769   arg1 = (Dali::CameraActor *)jarg1;
48770   arg2 = (Dali::Vector3 *)jarg2;
48771   if (!arg2) {
48772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48773     return ;
48774   }
48775   {
48776     try {
48777       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48778     } catch (std::out_of_range& e) {
48779       {
48780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48781       };
48782     } catch (std::exception& e) {
48783       {
48784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48785       };
48786     } catch (Dali::DaliException e) {
48787       {
48788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48789       };
48790     } catch (...) {
48791       {
48792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48793       };
48794     }
48795   }
48796
48797 }
48798
48799
48800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48801   void * jresult ;
48802   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48803   Dali::Vector3 result;
48804
48805   arg1 = (Dali::CameraActor *)jarg1;
48806   {
48807     try {
48808       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48809     } catch (std::out_of_range& e) {
48810       {
48811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48812       };
48813     } catch (std::exception& e) {
48814       {
48815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48816       };
48817     } catch (Dali::DaliException e) {
48818       {
48819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48820       };
48821     } catch (...) {
48822       {
48823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48824       };
48825     }
48826   }
48827
48828   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48829   return jresult;
48830 }
48831
48832
48833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48834   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48835   bool arg2 ;
48836
48837   arg1 = (Dali::CameraActor *)jarg1;
48838   arg2 = jarg2 ? true : false;
48839   {
48840     try {
48841       (arg1)->SetInvertYAxis(arg2);
48842     } catch (std::out_of_range& e) {
48843       {
48844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48845       };
48846     } catch (std::exception& e) {
48847       {
48848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48849       };
48850     } catch (Dali::DaliException e) {
48851       {
48852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48853       };
48854     } catch (...) {
48855       {
48856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48857       };
48858     }
48859   }
48860
48861 }
48862
48863
48864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48865   unsigned int jresult ;
48866   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48867   bool result;
48868
48869   arg1 = (Dali::CameraActor *)jarg1;
48870   {
48871     try {
48872       result = (bool)(arg1)->GetInvertYAxis();
48873     } catch (std::out_of_range& e) {
48874       {
48875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48876       };
48877     } catch (std::exception& e) {
48878       {
48879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48880       };
48881     } catch (Dali::DaliException e) {
48882       {
48883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48884       };
48885     } catch (...) {
48886       {
48887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48888       };
48889     }
48890   }
48891
48892   jresult = result;
48893   return jresult;
48894 }
48895
48896
48897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48898   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48899   Dali::Size *arg2 = 0 ;
48900
48901   arg1 = (Dali::CameraActor *)jarg1;
48902   arg2 = (Dali::Size *)jarg2;
48903   if (!arg2) {
48904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48905     return ;
48906   }
48907   {
48908     try {
48909       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48910     } catch (std::out_of_range& e) {
48911       {
48912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48913       };
48914     } catch (std::exception& e) {
48915       {
48916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48917       };
48918     } catch (Dali::DaliException e) {
48919       {
48920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48921       };
48922     } catch (...) {
48923       {
48924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48925       };
48926     }
48927   }
48928
48929 }
48930
48931
48932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48933   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48934   Dali::Size *arg2 = 0 ;
48935
48936   arg1 = (Dali::CameraActor *)jarg1;
48937   arg2 = (Dali::Size *)jarg2;
48938   if (!arg2) {
48939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48940     return ;
48941   }
48942   {
48943     try {
48944       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48945     } catch (std::out_of_range& e) {
48946       {
48947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48948       };
48949     } catch (std::exception& e) {
48950       {
48951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48952       };
48953     } catch (Dali::DaliException e) {
48954       {
48955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48956       };
48957     } catch (...) {
48958       {
48959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48960       };
48961     }
48962   }
48963
48964 }
48965
48966
48967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48968   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48969   float arg2 ;
48970   float arg3 ;
48971   float arg4 ;
48972   float arg5 ;
48973   float arg6 ;
48974   float arg7 ;
48975
48976   arg1 = (Dali::CameraActor *)jarg1;
48977   arg2 = (float)jarg2;
48978   arg3 = (float)jarg3;
48979   arg4 = (float)jarg4;
48980   arg5 = (float)jarg5;
48981   arg6 = (float)jarg6;
48982   arg7 = (float)jarg7;
48983   {
48984     try {
48985       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48986     } catch (std::out_of_range& e) {
48987       {
48988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48989       };
48990     } catch (std::exception& e) {
48991       {
48992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48993       };
48994     } catch (Dali::DaliException e) {
48995       {
48996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48997       };
48998     } catch (...) {
48999       {
49000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49001       };
49002     }
49003   }
49004
49005 }
49006
49007
49008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49009   void * jresult ;
49010   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49011
49012   {
49013     try {
49014       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49015     } catch (std::out_of_range& e) {
49016       {
49017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49018       };
49019     } catch (std::exception& e) {
49020       {
49021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49022       };
49023     } catch (Dali::DaliException e) {
49024       {
49025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49026       };
49027     } catch (...) {
49028       {
49029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49030       };
49031     }
49032   }
49033
49034   jresult = (void *)result;
49035   return jresult;
49036 }
49037
49038
49039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49040   void * jresult ;
49041   std::string arg1 ;
49042   Dali::Property::Value arg2 ;
49043   Dali::Property::Value *argp2 ;
49044   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49045
49046   if (!jarg1) {
49047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49048     return 0;
49049   }
49050   (&arg1)->assign(jarg1);
49051   argp2 = (Dali::Property::Value *)jarg2;
49052   if (!argp2) {
49053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49054     return 0;
49055   }
49056   arg2 = *argp2;
49057   {
49058     try {
49059       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49060     } catch (std::out_of_range& e) {
49061       {
49062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49063       };
49064     } catch (std::exception& e) {
49065       {
49066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49067       };
49068     } catch (Dali::DaliException e) {
49069       {
49070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49071       };
49072     } catch (...) {
49073       {
49074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49075       };
49076     }
49077   }
49078
49079   jresult = (void *)result;
49080   return jresult;
49081 }
49082
49083
49084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49085   void * jresult ;
49086   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49087   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49088
49089   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49090   if (!arg1) {
49091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49092     return 0;
49093   }
49094   {
49095     try {
49096       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);
49097     } catch (std::out_of_range& e) {
49098       {
49099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49100       };
49101     } catch (std::exception& e) {
49102       {
49103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49104       };
49105     } catch (Dali::DaliException e) {
49106       {
49107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49108       };
49109     } catch (...) {
49110       {
49111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49112       };
49113     }
49114   }
49115
49116   jresult = (void *)result;
49117   return jresult;
49118 }
49119
49120
49121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49122   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49123   std::string *arg2 = 0 ;
49124
49125   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49126   if (!jarg2) {
49127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49128     return ;
49129   }
49130   std::string arg2_str(jarg2);
49131   arg2 = &arg2_str;
49132   if (arg1) (arg1)->first = *arg2;
49133
49134   //argout typemap for const std::string&
49135
49136 }
49137
49138
49139 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49140   char * jresult ;
49141   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49142   std::string *result = 0 ;
49143
49144   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49145   result = (std::string *) & ((arg1)->first);
49146   jresult = SWIG_csharp_string_callback(result->c_str());
49147   return jresult;
49148 }
49149
49150
49151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49152   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49153   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49154
49155   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49156   arg2 = (Dali::Property::Value *)jarg2;
49157   if (arg1) (arg1)->second = *arg2;
49158 }
49159
49160
49161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49162   void * jresult ;
49163   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49164   Dali::Property::Value *result = 0 ;
49165
49166   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49167   result = (Dali::Property::Value *)& ((arg1)->second);
49168   jresult = (void *)result;
49169   return jresult;
49170 }
49171
49172
49173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49174   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49175
49176   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49177   {
49178     try {
49179       delete arg1;
49180     } catch (std::out_of_range& e) {
49181       {
49182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49183       };
49184     } catch (std::exception& e) {
49185       {
49186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49187       };
49188     } catch (Dali::DaliException e) {
49189       {
49190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49191       };
49192     } catch (...) {
49193       {
49194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49195       };
49196     }
49197   }
49198
49199 }
49200
49201
49202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49203   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49204
49205   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49206   {
49207     try {
49208       (arg1)->clear();
49209     } catch (std::out_of_range& e) {
49210       {
49211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49212       };
49213     } catch (std::exception& e) {
49214       {
49215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49216       };
49217     } catch (Dali::DaliException e) {
49218       {
49219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49220       };
49221     } catch (...) {
49222       {
49223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49224       };
49225     }
49226   }
49227
49228 }
49229
49230
49231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49232   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49233   Dali::TouchPoint *arg2 = 0 ;
49234
49235   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49236   arg2 = (Dali::TouchPoint *)jarg2;
49237   if (!arg2) {
49238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49239     return ;
49240   }
49241   {
49242     try {
49243       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49244     } catch (std::out_of_range& e) {
49245       {
49246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49247       };
49248     } catch (std::exception& e) {
49249       {
49250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49251       };
49252     } catch (Dali::DaliException e) {
49253       {
49254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49255       };
49256     } catch (...) {
49257       {
49258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49259       };
49260     }
49261   }
49262
49263 }
49264
49265
49266 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49267   unsigned long jresult ;
49268   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49269   std::vector< Dali::TouchPoint >::size_type result;
49270
49271   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49272   {
49273     try {
49274       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49275     } catch (std::out_of_range& e) {
49276       {
49277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49278       };
49279     } catch (std::exception& e) {
49280       {
49281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49282       };
49283     } catch (Dali::DaliException e) {
49284       {
49285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49286       };
49287     } catch (...) {
49288       {
49289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49290       };
49291     }
49292   }
49293
49294   jresult = (unsigned long)result;
49295   return jresult;
49296 }
49297
49298
49299 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49300   unsigned long jresult ;
49301   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49302   std::vector< Dali::TouchPoint >::size_type result;
49303
49304   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49305   {
49306     try {
49307       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49308     } catch (std::out_of_range& e) {
49309       {
49310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49311       };
49312     } catch (std::exception& e) {
49313       {
49314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49315       };
49316     } catch (Dali::DaliException e) {
49317       {
49318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49319       };
49320     } catch (...) {
49321       {
49322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49323       };
49324     }
49325   }
49326
49327   jresult = (unsigned long)result;
49328   return jresult;
49329 }
49330
49331
49332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49333   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49334   std::vector< Dali::TouchPoint >::size_type arg2 ;
49335
49336   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49337   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49338   {
49339     try {
49340       (arg1)->reserve(arg2);
49341     } catch (std::out_of_range& e) {
49342       {
49343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49344       };
49345     } catch (std::exception& e) {
49346       {
49347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49348       };
49349     } catch (Dali::DaliException e) {
49350       {
49351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49352       };
49353     } catch (...) {
49354       {
49355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49356       };
49357     }
49358   }
49359
49360 }
49361
49362
49363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49364   void * jresult ;
49365   std::vector< Dali::TouchPoint > *result = 0 ;
49366
49367   {
49368     try {
49369       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49370     } catch (std::out_of_range& e) {
49371       {
49372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49373       };
49374     } catch (std::exception& e) {
49375       {
49376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49377       };
49378     } catch (Dali::DaliException e) {
49379       {
49380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49381       };
49382     } catch (...) {
49383       {
49384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49385       };
49386     }
49387   }
49388
49389   jresult = (void *)result;
49390   return jresult;
49391 }
49392
49393
49394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49395   void * jresult ;
49396   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49397   std::vector< Dali::TouchPoint > *result = 0 ;
49398
49399   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49400   if (!arg1) {
49401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49402     return 0;
49403   }
49404   {
49405     try {
49406       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49407     } catch (std::out_of_range& e) {
49408       {
49409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49410       };
49411     } catch (std::exception& e) {
49412       {
49413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49414       };
49415     } catch (Dali::DaliException e) {
49416       {
49417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49418       };
49419     } catch (...) {
49420       {
49421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49422       };
49423     }
49424   }
49425
49426   jresult = (void *)result;
49427   return jresult;
49428 }
49429
49430
49431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49432   void * jresult ;
49433   int arg1 ;
49434   std::vector< Dali::TouchPoint > *result = 0 ;
49435
49436   arg1 = (int)jarg1;
49437   {
49438     try {
49439       try {
49440         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49441       }
49442       catch(std::out_of_range &_e) {
49443         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49444         return 0;
49445       }
49446
49447     } catch (std::out_of_range& e) {
49448       {
49449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49450       };
49451     } catch (std::exception& e) {
49452       {
49453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49454       };
49455     } catch (Dali::DaliException e) {
49456       {
49457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49458       };
49459     } catch (...) {
49460       {
49461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49462       };
49463     }
49464   }
49465
49466   jresult = (void *)result;
49467   return jresult;
49468 }
49469
49470
49471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49472   void * jresult ;
49473   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49474   int arg2 ;
49475   SwigValueWrapper< Dali::TouchPoint > result;
49476
49477   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49478   arg2 = (int)jarg2;
49479   {
49480     try {
49481       try {
49482         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49483       }
49484       catch(std::out_of_range &_e) {
49485         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49486         return 0;
49487       }
49488
49489     } catch (std::out_of_range& e) {
49490       {
49491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49492       };
49493     } catch (std::exception& e) {
49494       {
49495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49496       };
49497     } catch (Dali::DaliException e) {
49498       {
49499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49500       };
49501     } catch (...) {
49502       {
49503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49504       };
49505     }
49506   }
49507
49508   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49509   return jresult;
49510 }
49511
49512
49513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49514   void * jresult ;
49515   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49516   int arg2 ;
49517   Dali::TouchPoint *result = 0 ;
49518
49519   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49520   arg2 = (int)jarg2;
49521   {
49522     try {
49523       try {
49524         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49525       }
49526       catch(std::out_of_range &_e) {
49527         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49528         return 0;
49529       }
49530
49531     } catch (std::out_of_range& e) {
49532       {
49533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49534       };
49535     } catch (std::exception& e) {
49536       {
49537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49538       };
49539     } catch (Dali::DaliException e) {
49540       {
49541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49542       };
49543     } catch (...) {
49544       {
49545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49546       };
49547     }
49548   }
49549
49550   jresult = (void *)result;
49551   return jresult;
49552 }
49553
49554
49555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49556   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49557   int arg2 ;
49558   Dali::TouchPoint *arg3 = 0 ;
49559
49560   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49561   arg2 = (int)jarg2;
49562   arg3 = (Dali::TouchPoint *)jarg3;
49563   if (!arg3) {
49564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49565     return ;
49566   }
49567   {
49568     try {
49569       try {
49570         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49571       }
49572       catch(std::out_of_range &_e) {
49573         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49574         return ;
49575       }
49576
49577     } catch (std::out_of_range& e) {
49578       {
49579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49580       };
49581     } catch (std::exception& e) {
49582       {
49583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49584       };
49585     } catch (Dali::DaliException e) {
49586       {
49587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49588       };
49589     } catch (...) {
49590       {
49591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49592       };
49593     }
49594   }
49595
49596 }
49597
49598
49599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49600   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49601   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49602
49603   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49604   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49605   if (!arg2) {
49606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49607     return ;
49608   }
49609   {
49610     try {
49611       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49612     } catch (std::out_of_range& e) {
49613       {
49614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49615       };
49616     } catch (std::exception& e) {
49617       {
49618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49619       };
49620     } catch (Dali::DaliException e) {
49621       {
49622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49623       };
49624     } catch (...) {
49625       {
49626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49627       };
49628     }
49629   }
49630
49631 }
49632
49633
49634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49635   void * jresult ;
49636   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49637   int arg2 ;
49638   int arg3 ;
49639   std::vector< Dali::TouchPoint > *result = 0 ;
49640
49641   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49642   arg2 = (int)jarg2;
49643   arg3 = (int)jarg3;
49644   {
49645     try {
49646       try {
49647         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49648       }
49649       catch(std::out_of_range &_e) {
49650         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49651         return 0;
49652       }
49653       catch(std::invalid_argument &_e) {
49654         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49655         return 0;
49656       }
49657
49658     } catch (std::out_of_range& e) {
49659       {
49660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49661       };
49662     } catch (std::exception& e) {
49663       {
49664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49665       };
49666     } catch (Dali::DaliException e) {
49667       {
49668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49669       };
49670     } catch (...) {
49671       {
49672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49673       };
49674     }
49675   }
49676
49677   jresult = (void *)result;
49678   return jresult;
49679 }
49680
49681
49682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49683   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49684   int arg2 ;
49685   Dali::TouchPoint *arg3 = 0 ;
49686
49687   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49688   arg2 = (int)jarg2;
49689   arg3 = (Dali::TouchPoint *)jarg3;
49690   if (!arg3) {
49691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49692     return ;
49693   }
49694   {
49695     try {
49696       try {
49697         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49698       }
49699       catch(std::out_of_range &_e) {
49700         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49701         return ;
49702       }
49703
49704     } catch (std::out_of_range& e) {
49705       {
49706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49707       };
49708     } catch (std::exception& e) {
49709       {
49710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49711       };
49712     } catch (Dali::DaliException e) {
49713       {
49714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49715       };
49716     } catch (...) {
49717       {
49718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49719       };
49720     }
49721   }
49722
49723 }
49724
49725
49726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49727   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49728   int arg2 ;
49729   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49730
49731   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49732   arg2 = (int)jarg2;
49733   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49734   if (!arg3) {
49735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49736     return ;
49737   }
49738   {
49739     try {
49740       try {
49741         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49742       }
49743       catch(std::out_of_range &_e) {
49744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49745         return ;
49746       }
49747
49748     } catch (std::out_of_range& e) {
49749       {
49750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49751       };
49752     } catch (std::exception& e) {
49753       {
49754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49755       };
49756     } catch (Dali::DaliException e) {
49757       {
49758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49759       };
49760     } catch (...) {
49761       {
49762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49763       };
49764     }
49765   }
49766
49767 }
49768
49769
49770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49771   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49772   int arg2 ;
49773
49774   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49775   arg2 = (int)jarg2;
49776   {
49777     try {
49778       try {
49779         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49780       }
49781       catch(std::out_of_range &_e) {
49782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49783         return ;
49784       }
49785
49786     } catch (std::out_of_range& e) {
49787       {
49788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49789       };
49790     } catch (std::exception& e) {
49791       {
49792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49793       };
49794     } catch (Dali::DaliException e) {
49795       {
49796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49797       };
49798     } catch (...) {
49799       {
49800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49801       };
49802     }
49803   }
49804
49805 }
49806
49807
49808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49809   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49810   int arg2 ;
49811   int arg3 ;
49812
49813   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49814   arg2 = (int)jarg2;
49815   arg3 = (int)jarg3;
49816   {
49817     try {
49818       try {
49819         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49820       }
49821       catch(std::out_of_range &_e) {
49822         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49823         return ;
49824       }
49825       catch(std::invalid_argument &_e) {
49826         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49827         return ;
49828       }
49829
49830     } catch (std::out_of_range& e) {
49831       {
49832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49833       };
49834     } catch (std::exception& e) {
49835       {
49836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49837       };
49838     } catch (Dali::DaliException e) {
49839       {
49840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49841       };
49842     } catch (...) {
49843       {
49844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49845       };
49846     }
49847   }
49848
49849 }
49850
49851
49852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49853   void * jresult ;
49854   Dali::TouchPoint *arg1 = 0 ;
49855   int arg2 ;
49856   std::vector< Dali::TouchPoint > *result = 0 ;
49857
49858   arg1 = (Dali::TouchPoint *)jarg1;
49859   if (!arg1) {
49860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49861     return 0;
49862   }
49863   arg2 = (int)jarg2;
49864   {
49865     try {
49866       try {
49867         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49868       }
49869       catch(std::out_of_range &_e) {
49870         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49871         return 0;
49872       }
49873
49874     } catch (std::out_of_range& e) {
49875       {
49876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49877       };
49878     } catch (std::exception& e) {
49879       {
49880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49881       };
49882     } catch (Dali::DaliException e) {
49883       {
49884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49885       };
49886     } catch (...) {
49887       {
49888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49889       };
49890     }
49891   }
49892
49893   jresult = (void *)result;
49894   return jresult;
49895 }
49896
49897
49898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49899   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49900
49901   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49902   {
49903     try {
49904       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49905     } catch (std::out_of_range& e) {
49906       {
49907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49908       };
49909     } catch (std::exception& e) {
49910       {
49911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49912       };
49913     } catch (Dali::DaliException e) {
49914       {
49915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49916       };
49917     } catch (...) {
49918       {
49919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49920       };
49921     }
49922   }
49923
49924 }
49925
49926
49927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49928   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49929   int arg2 ;
49930   int arg3 ;
49931
49932   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49933   arg2 = (int)jarg2;
49934   arg3 = (int)jarg3;
49935   {
49936     try {
49937       try {
49938         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49939       }
49940       catch(std::out_of_range &_e) {
49941         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49942         return ;
49943       }
49944       catch(std::invalid_argument &_e) {
49945         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49946         return ;
49947       }
49948
49949     } catch (std::out_of_range& e) {
49950       {
49951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49952       };
49953     } catch (std::exception& e) {
49954       {
49955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49956       };
49957     } catch (Dali::DaliException e) {
49958       {
49959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49960       };
49961     } catch (...) {
49962       {
49963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49964       };
49965     }
49966   }
49967
49968 }
49969
49970
49971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49972   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49973   int arg2 ;
49974   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49975
49976   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49977   arg2 = (int)jarg2;
49978   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49979   if (!arg3) {
49980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49981     return ;
49982   }
49983   {
49984     try {
49985       try {
49986         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49987       }
49988       catch(std::out_of_range &_e) {
49989         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49990         return ;
49991       }
49992
49993     } catch (std::out_of_range& e) {
49994       {
49995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49996       };
49997     } catch (std::exception& e) {
49998       {
49999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50000       };
50001     } catch (Dali::DaliException e) {
50002       {
50003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50004       };
50005     } catch (...) {
50006       {
50007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50008       };
50009     }
50010   }
50011
50012 }
50013
50014
50015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50016   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50017
50018   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50019   {
50020     try {
50021       delete arg1;
50022     } catch (std::out_of_range& e) {
50023       {
50024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50025       };
50026     } catch (std::exception& e) {
50027       {
50028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50029       };
50030     } catch (Dali::DaliException e) {
50031       {
50032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50033       };
50034     } catch (...) {
50035       {
50036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50037       };
50038     }
50039   }
50040
50041 }
50042
50043
50044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50045   void * jresult ;
50046   Dali::Rect< int > *result = 0 ;
50047
50048   {
50049     try {
50050       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50051     } catch (std::out_of_range& e) {
50052       {
50053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50054       };
50055     } catch (std::exception& e) {
50056       {
50057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50058       };
50059     } catch (Dali::DaliException e) {
50060       {
50061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50062       };
50063     } catch (...) {
50064       {
50065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50066       };
50067     }
50068   }
50069
50070   jresult = (void *)result;
50071   return jresult;
50072 }
50073
50074
50075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50076   void * jresult ;
50077   int arg1 ;
50078   int arg2 ;
50079   int arg3 ;
50080   int arg4 ;
50081   Dali::Rect< int > *result = 0 ;
50082
50083   arg1 = (int)jarg1;
50084   arg2 = (int)jarg2;
50085   arg3 = (int)jarg3;
50086   arg4 = (int)jarg4;
50087   {
50088     try {
50089       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50090     } catch (std::out_of_range& e) {
50091       {
50092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50093       };
50094     } catch (std::exception& e) {
50095       {
50096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50097       };
50098     } catch (Dali::DaliException e) {
50099       {
50100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50101       };
50102     } catch (...) {
50103       {
50104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50105       };
50106     }
50107   }
50108
50109   jresult = (void *)result;
50110   return jresult;
50111 }
50112
50113
50114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50115   void * jresult ;
50116   Dali::Rect< int > *arg1 = 0 ;
50117   Dali::Rect< int > *result = 0 ;
50118
50119   arg1 = (Dali::Rect< int > *)jarg1;
50120   if (!arg1) {
50121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50122     return 0;
50123   }
50124   {
50125     try {
50126       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50127     } catch (std::out_of_range& e) {
50128       {
50129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50130       };
50131     } catch (std::exception& e) {
50132       {
50133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50134       };
50135     } catch (Dali::DaliException e) {
50136       {
50137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50138       };
50139     } catch (...) {
50140       {
50141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50142       };
50143     }
50144   }
50145
50146   jresult = (void *)result;
50147   return jresult;
50148 }
50149
50150
50151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50152   void * jresult ;
50153   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50154   Dali::Rect< int > *arg2 = 0 ;
50155   Dali::Rect< int > *result = 0 ;
50156
50157   arg1 = (Dali::Rect< int > *)jarg1;
50158   arg2 = (Dali::Rect< int > *)jarg2;
50159   if (!arg2) {
50160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50161     return 0;
50162   }
50163   {
50164     try {
50165       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50166     } catch (std::out_of_range& e) {
50167       {
50168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50169       };
50170     } catch (std::exception& e) {
50171       {
50172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50173       };
50174     } catch (Dali::DaliException e) {
50175       {
50176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50177       };
50178     } catch (...) {
50179       {
50180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50181       };
50182     }
50183   }
50184
50185   jresult = (void *)result;
50186   return jresult;
50187 }
50188
50189
50190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50191   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50192   int arg2 ;
50193   int arg3 ;
50194   int arg4 ;
50195   int arg5 ;
50196
50197   arg1 = (Dali::Rect< int > *)jarg1;
50198   arg2 = (int)jarg2;
50199   arg3 = (int)jarg3;
50200   arg4 = (int)jarg4;
50201   arg5 = (int)jarg5;
50202   {
50203     try {
50204       (arg1)->Set(arg2,arg3,arg4,arg5);
50205     } catch (std::out_of_range& e) {
50206       {
50207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50208       };
50209     } catch (std::exception& e) {
50210       {
50211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50212       };
50213     } catch (Dali::DaliException e) {
50214       {
50215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50216       };
50217     } catch (...) {
50218       {
50219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50220       };
50221     }
50222   }
50223
50224 }
50225
50226
50227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50228   unsigned int jresult ;
50229   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50230   bool result;
50231
50232   arg1 = (Dali::Rect< int > *)jarg1;
50233   {
50234     try {
50235       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50236     } catch (std::out_of_range& e) {
50237       {
50238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50239       };
50240     } catch (std::exception& e) {
50241       {
50242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50243       };
50244     } catch (Dali::DaliException e) {
50245       {
50246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50247       };
50248     } catch (...) {
50249       {
50250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50251       };
50252     }
50253   }
50254
50255   jresult = result;
50256   return jresult;
50257 }
50258
50259
50260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50261   int jresult ;
50262   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50263   int result;
50264
50265   arg1 = (Dali::Rect< int > *)jarg1;
50266   {
50267     try {
50268       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50269     } catch (std::out_of_range& e) {
50270       {
50271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50272       };
50273     } catch (std::exception& e) {
50274       {
50275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50276       };
50277     } catch (Dali::DaliException e) {
50278       {
50279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50280       };
50281     } catch (...) {
50282       {
50283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50284       };
50285     }
50286   }
50287
50288   jresult = result;
50289   return jresult;
50290 }
50291
50292
50293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50294   int jresult ;
50295   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50296   int result;
50297
50298   arg1 = (Dali::Rect< int > *)jarg1;
50299   {
50300     try {
50301       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50302     } catch (std::out_of_range& e) {
50303       {
50304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50305       };
50306     } catch (std::exception& e) {
50307       {
50308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50309       };
50310     } catch (Dali::DaliException e) {
50311       {
50312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50313       };
50314     } catch (...) {
50315       {
50316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50317       };
50318     }
50319   }
50320
50321   jresult = result;
50322   return jresult;
50323 }
50324
50325
50326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50327   int jresult ;
50328   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50329   int result;
50330
50331   arg1 = (Dali::Rect< int > *)jarg1;
50332   {
50333     try {
50334       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50335     } catch (std::out_of_range& e) {
50336       {
50337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50338       };
50339     } catch (std::exception& e) {
50340       {
50341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50342       };
50343     } catch (Dali::DaliException e) {
50344       {
50345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50346       };
50347     } catch (...) {
50348       {
50349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50350       };
50351     }
50352   }
50353
50354   jresult = result;
50355   return jresult;
50356 }
50357
50358
50359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50360   int jresult ;
50361   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50362   int result;
50363
50364   arg1 = (Dali::Rect< int > *)jarg1;
50365   {
50366     try {
50367       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50368     } catch (std::out_of_range& e) {
50369       {
50370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50371       };
50372     } catch (std::exception& e) {
50373       {
50374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50375       };
50376     } catch (Dali::DaliException e) {
50377       {
50378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50379       };
50380     } catch (...) {
50381       {
50382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50383       };
50384     }
50385   }
50386
50387   jresult = result;
50388   return jresult;
50389 }
50390
50391
50392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50393   int jresult ;
50394   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50395   int result;
50396
50397   arg1 = (Dali::Rect< int > *)jarg1;
50398   {
50399     try {
50400       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50401     } catch (std::out_of_range& e) {
50402       {
50403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50404       };
50405     } catch (std::exception& e) {
50406       {
50407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50408       };
50409     } catch (Dali::DaliException e) {
50410       {
50411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50412       };
50413     } catch (...) {
50414       {
50415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50416       };
50417     }
50418   }
50419
50420   jresult = result;
50421   return jresult;
50422 }
50423
50424
50425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50426   unsigned int jresult ;
50427   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50428   Dali::Rect< int > *arg2 = 0 ;
50429   bool result;
50430
50431   arg1 = (Dali::Rect< int > *)jarg1;
50432   arg2 = (Dali::Rect< int > *)jarg2;
50433   if (!arg2) {
50434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50435     return 0;
50436   }
50437   {
50438     try {
50439       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50440     } catch (std::out_of_range& e) {
50441       {
50442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50443       };
50444     } catch (std::exception& e) {
50445       {
50446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50447       };
50448     } catch (Dali::DaliException e) {
50449       {
50450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50451       };
50452     } catch (...) {
50453       {
50454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50455       };
50456     }
50457   }
50458
50459   jresult = result;
50460   return jresult;
50461 }
50462
50463
50464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50465   unsigned int jresult ;
50466   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50467   Dali::Rect< int > *arg2 = 0 ;
50468   bool result;
50469
50470   arg1 = (Dali::Rect< int > *)jarg1;
50471   arg2 = (Dali::Rect< int > *)jarg2;
50472   if (!arg2) {
50473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50474     return 0;
50475   }
50476   {
50477     try {
50478       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50479     } catch (std::out_of_range& e) {
50480       {
50481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50482       };
50483     } catch (std::exception& e) {
50484       {
50485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50486       };
50487     } catch (Dali::DaliException e) {
50488       {
50489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50490       };
50491     } catch (...) {
50492       {
50493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50494       };
50495     }
50496   }
50497
50498   jresult = result;
50499   return jresult;
50500 }
50501
50502
50503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50504   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50505   int arg2 ;
50506
50507   arg1 = (Dali::Rect< int > *)jarg1;
50508   arg2 = (int)jarg2;
50509   if (arg1) (arg1)->x = arg2;
50510 }
50511
50512
50513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50514   int jresult ;
50515   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50516   int result;
50517
50518   arg1 = (Dali::Rect< int > *)jarg1;
50519   result = (int) ((arg1)->x);
50520   jresult = result;
50521   return jresult;
50522 }
50523
50524
50525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50526   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50527   int arg2 ;
50528
50529   arg1 = (Dali::Rect< int > *)jarg1;
50530   arg2 = (int)jarg2;
50531   if (arg1) (arg1)->left = arg2;
50532 }
50533
50534
50535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50536   int jresult ;
50537   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50538   int result;
50539
50540   arg1 = (Dali::Rect< int > *)jarg1;
50541   result = (int) ((arg1)->left);
50542   jresult = result;
50543   return jresult;
50544 }
50545
50546
50547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50548   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50549   int arg2 ;
50550
50551   arg1 = (Dali::Rect< int > *)jarg1;
50552   arg2 = (int)jarg2;
50553   if (arg1) (arg1)->y = arg2;
50554 }
50555
50556
50557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50558   int jresult ;
50559   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50560   int result;
50561
50562   arg1 = (Dali::Rect< int > *)jarg1;
50563   result = (int) ((arg1)->y);
50564   jresult = result;
50565   return jresult;
50566 }
50567
50568
50569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50570   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50571   int arg2 ;
50572
50573   arg1 = (Dali::Rect< int > *)jarg1;
50574   arg2 = (int)jarg2;
50575   if (arg1) (arg1)->right = arg2;
50576 }
50577
50578
50579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50580   int jresult ;
50581   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50582   int result;
50583
50584   arg1 = (Dali::Rect< int > *)jarg1;
50585   result = (int) ((arg1)->right);
50586   jresult = result;
50587   return jresult;
50588 }
50589
50590
50591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50592   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50593   int arg2 ;
50594
50595   arg1 = (Dali::Rect< int > *)jarg1;
50596   arg2 = (int)jarg2;
50597   if (arg1) (arg1)->width = arg2;
50598 }
50599
50600
50601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50602   int jresult ;
50603   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50604   int result;
50605
50606   arg1 = (Dali::Rect< int > *)jarg1;
50607   result = (int) ((arg1)->width);
50608   jresult = result;
50609   return jresult;
50610 }
50611
50612
50613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50614   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50615   int arg2 ;
50616
50617   arg1 = (Dali::Rect< int > *)jarg1;
50618   arg2 = (int)jarg2;
50619   if (arg1) (arg1)->bottom = arg2;
50620 }
50621
50622
50623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50624   int jresult ;
50625   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50626   int result;
50627
50628   arg1 = (Dali::Rect< int > *)jarg1;
50629   result = (int) ((arg1)->bottom);
50630   jresult = result;
50631   return jresult;
50632 }
50633
50634
50635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50636   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50637   int arg2 ;
50638
50639   arg1 = (Dali::Rect< int > *)jarg1;
50640   arg2 = (int)jarg2;
50641   if (arg1) (arg1)->height = arg2;
50642 }
50643
50644
50645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50646   int jresult ;
50647   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50648   int result;
50649
50650   arg1 = (Dali::Rect< int > *)jarg1;
50651   result = (int) ((arg1)->height);
50652   jresult = result;
50653   return jresult;
50654 }
50655
50656
50657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50658   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50659   int arg2 ;
50660
50661   arg1 = (Dali::Rect< int > *)jarg1;
50662   arg2 = (int)jarg2;
50663   if (arg1) (arg1)->top = arg2;
50664 }
50665
50666
50667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50668   int jresult ;
50669   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50670   int result;
50671
50672   arg1 = (Dali::Rect< int > *)jarg1;
50673   result = (int) ((arg1)->top);
50674   jresult = result;
50675   return jresult;
50676 }
50677
50678
50679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50680   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50681
50682   arg1 = (Dali::Rect< int > *)jarg1;
50683   {
50684     try {
50685       delete arg1;
50686     } catch (std::out_of_range& e) {
50687       {
50688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50689       };
50690     } catch (std::exception& e) {
50691       {
50692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50693       };
50694     } catch (Dali::DaliException e) {
50695       {
50696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50697       };
50698     } catch (...) {
50699       {
50700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50701       };
50702     }
50703   }
50704
50705 }
50706
50707
50708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50709   void * jresult ;
50710   Dali::Rect< float > *result = 0 ;
50711
50712   {
50713     try {
50714       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50715     } catch (std::out_of_range& e) {
50716       {
50717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50718       };
50719     } catch (std::exception& e) {
50720       {
50721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50722       };
50723     } catch (Dali::DaliException e) {
50724       {
50725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50726       };
50727     } catch (...) {
50728       {
50729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50730       };
50731     }
50732   }
50733
50734   jresult = (void *)result;
50735   return jresult;
50736 }
50737
50738
50739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50740   void * jresult ;
50741   float arg1 ;
50742   float arg2 ;
50743   float arg3 ;
50744   float arg4 ;
50745   Dali::Rect< float > *result = 0 ;
50746
50747   arg1 = (float)jarg1;
50748   arg2 = (float)jarg2;
50749   arg3 = (float)jarg4;
50750   arg4 = (float)jarg3;
50751   {
50752     try {
50753       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50754     } catch (std::out_of_range& e) {
50755       {
50756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50757       };
50758     } catch (std::exception& e) {
50759       {
50760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50761       };
50762     } catch (Dali::DaliException e) {
50763       {
50764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50765       };
50766     } catch (...) {
50767       {
50768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50769       };
50770     }
50771   }
50772
50773   jresult = (void *)result;
50774   return jresult;
50775 }
50776
50777
50778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50779   void * jresult ;
50780   Dali::Rect< float > *arg1 = 0 ;
50781   Dali::Rect< float > *result = 0 ;
50782
50783   arg1 = (Dali::Rect< float > *)jarg1;
50784   if (!arg1) {
50785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50786     return 0;
50787   }
50788   {
50789     try {
50790       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50791     } catch (std::out_of_range& e) {
50792       {
50793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50794       };
50795     } catch (std::exception& e) {
50796       {
50797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50798       };
50799     } catch (Dali::DaliException e) {
50800       {
50801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50802       };
50803     } catch (...) {
50804       {
50805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50806       };
50807     }
50808   }
50809
50810   jresult = (void *)result;
50811   return jresult;
50812 }
50813
50814
50815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50816   void * jresult ;
50817   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50818   Dali::Rect< float > *arg2 = 0 ;
50819   Dali::Rect< float > *result = 0 ;
50820
50821   arg1 = (Dali::Rect< float > *)jarg1;
50822   arg2 = (Dali::Rect< float > *)jarg2;
50823   if (!arg2) {
50824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50825     return 0;
50826   }
50827   {
50828     try {
50829       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50830     } catch (std::out_of_range& e) {
50831       {
50832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50833       };
50834     } catch (std::exception& e) {
50835       {
50836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50837       };
50838     } catch (Dali::DaliException e) {
50839       {
50840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50841       };
50842     } catch (...) {
50843       {
50844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50845       };
50846     }
50847   }
50848
50849   jresult = (void *)result;
50850   return jresult;
50851 }
50852
50853
50854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50855   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50856   float arg2 ;
50857   float arg3 ;
50858   float arg4 ;
50859   float arg5 ;
50860
50861   arg1 = (Dali::Rect< float > *)jarg1;
50862   arg2 = (float)jarg2;
50863   arg3 = (float)jarg3;
50864   arg4 = (float)jarg5;
50865   arg5 = (float)jarg4;
50866   {
50867     try {
50868       (arg1)->Set(arg2,arg3,arg4,arg5);
50869     } catch (std::out_of_range& e) {
50870       {
50871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50872       };
50873     } catch (std::exception& e) {
50874       {
50875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50876       };
50877     } catch (Dali::DaliException e) {
50878       {
50879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50880       };
50881     } catch (...) {
50882       {
50883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50884       };
50885     }
50886   }
50887
50888 }
50889
50890
50891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50892   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50893   float arg2 ;
50894
50895   arg1 = (Dali::Rect< float > *)jarg1;
50896   arg2 = (float)jarg2;
50897   if (arg1) (arg1)->left = arg2;
50898 }
50899
50900
50901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50902   float jresult ;
50903   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50904   float result;
50905
50906   arg1 = (Dali::Rect< float > *)jarg1;
50907   result = (float) ((arg1)->left);
50908   jresult = result;
50909   return jresult;
50910 }
50911
50912
50913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50914   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50915   float arg2 ;
50916
50917   arg1 = (Dali::Rect< float > *)jarg1;
50918   arg2 = (float)jarg2;
50919   if (arg1) (arg1)->left = arg2;
50920 }
50921
50922
50923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50924   float jresult ;
50925   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50926   float result;
50927
50928   arg1 = (Dali::Rect< float > *)jarg1;
50929   result = (float) ((arg1)->left);
50930   jresult = result;
50931   return jresult;
50932 }
50933
50934
50935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50936   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50937   float arg2 ;
50938
50939   arg1 = (Dali::Rect< float > *)jarg1;
50940   arg2 = (float)jarg2;
50941   if (arg1) (arg1)->right = arg2;
50942 }
50943
50944
50945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50946   float jresult ;
50947   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50948   float result;
50949
50950   arg1 = (Dali::Rect< float > *)jarg1;
50951   result = (float) ((arg1)->right);
50952   jresult = result;
50953   return jresult;
50954 }
50955
50956
50957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50958   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50959   float arg2 ;
50960
50961   arg1 = (Dali::Rect< float > *)jarg1;
50962   arg2 = (float)jarg2;
50963   if (arg1) (arg1)->right = arg2;
50964 }
50965
50966
50967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50968   float jresult ;
50969   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50970   float result;
50971
50972   arg1 = (Dali::Rect< float > *)jarg1;
50973   result = (float) ((arg1)->right);
50974   jresult = result;
50975   return jresult;
50976 }
50977
50978
50979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50980   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50981   float arg2 ;
50982
50983   arg1 = (Dali::Rect< float > *)jarg1;
50984   arg2 = (float)jarg2;
50985   if (arg1) (arg1)->bottom = arg2;
50986 }
50987
50988
50989 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50990   float jresult ;
50991   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50992   float result;
50993
50994   arg1 = (Dali::Rect< float > *)jarg1;
50995   result = (float) ((arg1)->bottom);
50996   jresult = result;
50997   return jresult;
50998 }
50999
51000
51001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51002   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51003   float arg2 ;
51004
51005   arg1 = (Dali::Rect< float > *)jarg1;
51006   arg2 = (float)jarg2;
51007   if (arg1) (arg1)->top = arg2;
51008 }
51009
51010
51011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51012   float jresult ;
51013   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51014   float result;
51015
51016   arg1 = (Dali::Rect< float > *)jarg1;
51017   result = (float) ((arg1)->top);
51018   jresult = result;
51019   return jresult;
51020 }
51021
51022
51023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51024   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51025
51026   arg1 = (Dali::Rect< float > *)jarg1;
51027   {
51028     try {
51029       delete arg1;
51030     } catch (std::out_of_range& e) {
51031       {
51032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51033       };
51034     } catch (std::exception& e) {
51035       {
51036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51037       };
51038     } catch (Dali::DaliException e) {
51039       {
51040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51041       };
51042     } catch (...) {
51043       {
51044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51045       };
51046     }
51047   }
51048
51049 }
51050
51051
51052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51053   int jresult ;
51054   int result;
51055
51056   result = (int)Dali::Vector< int >::BaseType;
51057   jresult = (int)result;
51058   return jresult;
51059 }
51060
51061
51062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51063   void * jresult ;
51064   Dali::Vector< int > *result = 0 ;
51065
51066   {
51067     try {
51068       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51069     } catch (std::out_of_range& e) {
51070       {
51071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51072       };
51073     } catch (std::exception& e) {
51074       {
51075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51076       };
51077     } catch (Dali::DaliException e) {
51078       {
51079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51080       };
51081     } catch (...) {
51082       {
51083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51084       };
51085     }
51086   }
51087
51088   jresult = (void *)result;
51089   return jresult;
51090 }
51091
51092
51093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51094   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51095
51096   arg1 = (Dali::Vector< int > *)jarg1;
51097   {
51098     try {
51099       delete arg1;
51100     } catch (std::out_of_range& e) {
51101       {
51102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51103       };
51104     } catch (std::exception& e) {
51105       {
51106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51107       };
51108     } catch (Dali::DaliException e) {
51109       {
51110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51111       };
51112     } catch (...) {
51113       {
51114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51115       };
51116     }
51117   }
51118
51119 }
51120
51121
51122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51123   void * jresult ;
51124   Dali::Vector< int > *arg1 = 0 ;
51125   Dali::Vector< int > *result = 0 ;
51126
51127   arg1 = (Dali::Vector< int > *)jarg1;
51128   if (!arg1) {
51129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51130     return 0;
51131   }
51132   {
51133     try {
51134       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51135     } catch (std::out_of_range& e) {
51136       {
51137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51138       };
51139     } catch (std::exception& e) {
51140       {
51141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51142       };
51143     } catch (Dali::DaliException e) {
51144       {
51145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51146       };
51147     } catch (...) {
51148       {
51149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51150       };
51151     }
51152   }
51153
51154   jresult = (void *)result;
51155   return jresult;
51156 }
51157
51158
51159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51160   void * jresult ;
51161   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51162   Dali::Vector< int > *arg2 = 0 ;
51163   Dali::Vector< int > *result = 0 ;
51164
51165   arg1 = (Dali::Vector< int > *)jarg1;
51166   arg2 = (Dali::Vector< int > *)jarg2;
51167   if (!arg2) {
51168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51169     return 0;
51170   }
51171   {
51172     try {
51173       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51174     } catch (std::out_of_range& e) {
51175       {
51176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51177       };
51178     } catch (std::exception& e) {
51179       {
51180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51181       };
51182     } catch (Dali::DaliException e) {
51183       {
51184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51185       };
51186     } catch (...) {
51187       {
51188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51189       };
51190     }
51191   }
51192
51193   jresult = (void *)result;
51194   return jresult;
51195 }
51196
51197
51198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51199   void * jresult ;
51200   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51201   Dali::Vector< int >::Iterator result;
51202
51203   arg1 = (Dali::Vector< int > *)jarg1;
51204   {
51205     try {
51206       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51207     } catch (std::out_of_range& e) {
51208       {
51209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51210       };
51211     } catch (std::exception& e) {
51212       {
51213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51214       };
51215     } catch (Dali::DaliException e) {
51216       {
51217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51218       };
51219     } catch (...) {
51220       {
51221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51222       };
51223     }
51224   }
51225
51226   jresult = (void *)result;
51227   return jresult;
51228 }
51229
51230
51231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51232   void * jresult ;
51233   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51234   Dali::Vector< int >::Iterator result;
51235
51236   arg1 = (Dali::Vector< int > *)jarg1;
51237   {
51238     try {
51239       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51240     } catch (std::out_of_range& e) {
51241       {
51242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51243       };
51244     } catch (std::exception& e) {
51245       {
51246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51247       };
51248     } catch (Dali::DaliException e) {
51249       {
51250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51251       };
51252     } catch (...) {
51253       {
51254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51255       };
51256     }
51257   }
51258
51259   jresult = (void *)result;
51260   return jresult;
51261 }
51262
51263
51264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51265   void * jresult ;
51266   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51267   Dali::Vector< int >::SizeType arg2 ;
51268   Dali::Vector< int >::ItemType *result = 0 ;
51269
51270   arg1 = (Dali::Vector< int > *)jarg1;
51271   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51272   {
51273     try {
51274       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51275     } catch (std::out_of_range& e) {
51276       {
51277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51278       };
51279     } catch (std::exception& e) {
51280       {
51281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51282       };
51283     } catch (Dali::DaliException e) {
51284       {
51285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51286       };
51287     } catch (...) {
51288       {
51289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51290       };
51291     }
51292   }
51293
51294   jresult = (void *)result;
51295   return jresult;
51296 }
51297
51298
51299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51300   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51301   Dali::Vector< int >::ItemType *arg2 = 0 ;
51302   Dali::Vector< int >::ItemType temp2 ;
51303
51304   arg1 = (Dali::Vector< int > *)jarg1;
51305   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51306   arg2 = &temp2;
51307   {
51308     try {
51309       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51310     } catch (std::out_of_range& e) {
51311       {
51312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51313       };
51314     } catch (std::exception& e) {
51315       {
51316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51317       };
51318     } catch (Dali::DaliException e) {
51319       {
51320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51321       };
51322     } catch (...) {
51323       {
51324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51325       };
51326     }
51327   }
51328
51329 }
51330
51331
51332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51333   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51334   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51335   Dali::Vector< int >::ItemType *arg3 = 0 ;
51336   Dali::Vector< int >::ItemType temp3 ;
51337
51338   arg1 = (Dali::Vector< int > *)jarg1;
51339   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51340   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51341   arg3 = &temp3;
51342   {
51343     try {
51344       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51345     } catch (std::out_of_range& e) {
51346       {
51347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51348       };
51349     } catch (std::exception& e) {
51350       {
51351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51352       };
51353     } catch (Dali::DaliException e) {
51354       {
51355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51356       };
51357     } catch (...) {
51358       {
51359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51360       };
51361     }
51362   }
51363
51364 }
51365
51366
51367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51368   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51369   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51370   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51371   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51372
51373   arg1 = (Dali::Vector< int > *)jarg1;
51374   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51375   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51376   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51377   {
51378     try {
51379       (arg1)->Insert(arg2,arg3,arg4);
51380     } catch (std::out_of_range& e) {
51381       {
51382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51383       };
51384     } catch (std::exception& e) {
51385       {
51386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51387       };
51388     } catch (Dali::DaliException e) {
51389       {
51390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51391       };
51392     } catch (...) {
51393       {
51394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51395       };
51396     }
51397   }
51398
51399 }
51400
51401
51402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51403   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51404   Dali::Vector< int >::SizeType arg2 ;
51405
51406   arg1 = (Dali::Vector< int > *)jarg1;
51407   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51408   {
51409     try {
51410       (arg1)->Reserve(arg2);
51411     } catch (std::out_of_range& e) {
51412       {
51413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51414       };
51415     } catch (std::exception& e) {
51416       {
51417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51418       };
51419     } catch (Dali::DaliException e) {
51420       {
51421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51422       };
51423     } catch (...) {
51424       {
51425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51426       };
51427     }
51428   }
51429
51430 }
51431
51432
51433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51434   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51435   Dali::Vector< int >::SizeType arg2 ;
51436
51437   arg1 = (Dali::Vector< int > *)jarg1;
51438   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51439   {
51440     try {
51441       (arg1)->Resize(arg2);
51442     } catch (std::out_of_range& e) {
51443       {
51444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51445       };
51446     } catch (std::exception& e) {
51447       {
51448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51449       };
51450     } catch (Dali::DaliException e) {
51451       {
51452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51453       };
51454     } catch (...) {
51455       {
51456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51457       };
51458     }
51459   }
51460
51461 }
51462
51463
51464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51465   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51466   Dali::Vector< int >::SizeType arg2 ;
51467   Dali::Vector< int >::ItemType *arg3 = 0 ;
51468   Dali::Vector< int >::ItemType temp3 ;
51469
51470   arg1 = (Dali::Vector< int > *)jarg1;
51471   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51472   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51473   arg3 = &temp3;
51474   {
51475     try {
51476       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51477     } catch (std::out_of_range& e) {
51478       {
51479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51480       };
51481     } catch (std::exception& e) {
51482       {
51483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51484       };
51485     } catch (Dali::DaliException e) {
51486       {
51487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51488       };
51489     } catch (...) {
51490       {
51491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51492       };
51493     }
51494   }
51495
51496 }
51497
51498
51499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51500   void * jresult ;
51501   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51502   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51503   Dali::Vector< int >::Iterator result;
51504
51505   arg1 = (Dali::Vector< int > *)jarg1;
51506   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51507   {
51508     try {
51509       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51510     } catch (std::out_of_range& e) {
51511       {
51512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51513       };
51514     } catch (std::exception& e) {
51515       {
51516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51517       };
51518     } catch (Dali::DaliException e) {
51519       {
51520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51521       };
51522     } catch (...) {
51523       {
51524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51525       };
51526     }
51527   }
51528
51529   jresult = (void *)result;
51530   return jresult;
51531 }
51532
51533
51534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51535   void * jresult ;
51536   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51537   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51538   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51539   Dali::Vector< int >::Iterator result;
51540
51541   arg1 = (Dali::Vector< int > *)jarg1;
51542   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51543   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51544   {
51545     try {
51546       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51547     } catch (std::out_of_range& e) {
51548       {
51549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51550       };
51551     } catch (std::exception& e) {
51552       {
51553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51554       };
51555     } catch (Dali::DaliException e) {
51556       {
51557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51558       };
51559     } catch (...) {
51560       {
51561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51562       };
51563     }
51564   }
51565
51566   jresult = (void *)result;
51567   return jresult;
51568 }
51569
51570
51571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51572   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51573   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51574
51575   arg1 = (Dali::Vector< int > *)jarg1;
51576   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51577   {
51578     try {
51579       (arg1)->Remove(arg2);
51580     } catch (std::out_of_range& e) {
51581       {
51582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51583       };
51584     } catch (std::exception& e) {
51585       {
51586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51587       };
51588     } catch (Dali::DaliException e) {
51589       {
51590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51591       };
51592     } catch (...) {
51593       {
51594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51595       };
51596     }
51597   }
51598
51599 }
51600
51601
51602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51603   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51604   Dali::Vector< int > *arg2 = 0 ;
51605
51606   arg1 = (Dali::Vector< int > *)jarg1;
51607   arg2 = (Dali::Vector< int > *)jarg2;
51608   if (!arg2) {
51609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51610     return ;
51611   }
51612   {
51613     try {
51614       (arg1)->Swap(*arg2);
51615     } catch (std::out_of_range& e) {
51616       {
51617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51618       };
51619     } catch (std::exception& e) {
51620       {
51621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51622       };
51623     } catch (Dali::DaliException e) {
51624       {
51625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51626       };
51627     } catch (...) {
51628       {
51629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51630       };
51631     }
51632   }
51633
51634 }
51635
51636
51637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51638   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51639
51640   arg1 = (Dali::Vector< int > *)jarg1;
51641   {
51642     try {
51643       (arg1)->Clear();
51644     } catch (std::out_of_range& e) {
51645       {
51646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51647       };
51648     } catch (std::exception& e) {
51649       {
51650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51651       };
51652     } catch (Dali::DaliException e) {
51653       {
51654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51655       };
51656     } catch (...) {
51657       {
51658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51659       };
51660     }
51661   }
51662
51663 }
51664
51665
51666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51667   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51668
51669   arg1 = (Dali::Vector< int > *)jarg1;
51670   {
51671     try {
51672       (arg1)->Release();
51673     } catch (std::out_of_range& e) {
51674       {
51675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51676       };
51677     } catch (std::exception& e) {
51678       {
51679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51680       };
51681     } catch (Dali::DaliException e) {
51682       {
51683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51684       };
51685     } catch (...) {
51686       {
51687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51688       };
51689     }
51690   }
51691
51692 }
51693
51694
51695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51696   int jresult ;
51697   int result;
51698
51699   result = (int)Dali::Vector< float >::BaseType;
51700   jresult = (int)result;
51701   return jresult;
51702 }
51703
51704
51705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51706   void * jresult ;
51707   Dali::Vector< float > *result = 0 ;
51708
51709   {
51710     try {
51711       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51712     } catch (std::out_of_range& e) {
51713       {
51714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51715       };
51716     } catch (std::exception& e) {
51717       {
51718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51719       };
51720     } catch (Dali::DaliException e) {
51721       {
51722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51723       };
51724     } catch (...) {
51725       {
51726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51727       };
51728     }
51729   }
51730
51731   jresult = (void *)result;
51732   return jresult;
51733 }
51734
51735
51736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51737   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51738
51739   arg1 = (Dali::Vector< float > *)jarg1;
51740   {
51741     try {
51742       delete arg1;
51743     } catch (std::out_of_range& e) {
51744       {
51745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51746       };
51747     } catch (std::exception& e) {
51748       {
51749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51750       };
51751     } catch (Dali::DaliException e) {
51752       {
51753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51754       };
51755     } catch (...) {
51756       {
51757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51758       };
51759     }
51760   }
51761
51762 }
51763
51764
51765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51766   void * jresult ;
51767   Dali::Vector< float > *arg1 = 0 ;
51768   Dali::Vector< float > *result = 0 ;
51769
51770   arg1 = (Dali::Vector< float > *)jarg1;
51771   if (!arg1) {
51772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51773     return 0;
51774   }
51775   {
51776     try {
51777       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51778     } catch (std::out_of_range& e) {
51779       {
51780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51781       };
51782     } catch (std::exception& e) {
51783       {
51784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51785       };
51786     } catch (Dali::DaliException e) {
51787       {
51788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51789       };
51790     } catch (...) {
51791       {
51792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51793       };
51794     }
51795   }
51796
51797   jresult = (void *)result;
51798   return jresult;
51799 }
51800
51801
51802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51803   void * jresult ;
51804   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51805   Dali::Vector< float > *arg2 = 0 ;
51806   Dali::Vector< float > *result = 0 ;
51807
51808   arg1 = (Dali::Vector< float > *)jarg1;
51809   arg2 = (Dali::Vector< float > *)jarg2;
51810   if (!arg2) {
51811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51812     return 0;
51813   }
51814   {
51815     try {
51816       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51817     } catch (std::out_of_range& e) {
51818       {
51819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51820       };
51821     } catch (std::exception& e) {
51822       {
51823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51824       };
51825     } catch (Dali::DaliException e) {
51826       {
51827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51828       };
51829     } catch (...) {
51830       {
51831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51832       };
51833     }
51834   }
51835
51836   jresult = (void *)result;
51837   return jresult;
51838 }
51839
51840
51841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51842   void * jresult ;
51843   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51844   Dali::Vector< float >::Iterator result;
51845
51846   arg1 = (Dali::Vector< float > *)jarg1;
51847   {
51848     try {
51849       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51850     } catch (std::out_of_range& e) {
51851       {
51852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51853       };
51854     } catch (std::exception& e) {
51855       {
51856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51857       };
51858     } catch (Dali::DaliException e) {
51859       {
51860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51861       };
51862     } catch (...) {
51863       {
51864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51865       };
51866     }
51867   }
51868
51869   jresult = (void *)result;
51870   return jresult;
51871 }
51872
51873
51874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51875   void * jresult ;
51876   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51877   Dali::Vector< float >::Iterator result;
51878
51879   arg1 = (Dali::Vector< float > *)jarg1;
51880   {
51881     try {
51882       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51883     } catch (std::out_of_range& e) {
51884       {
51885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51886       };
51887     } catch (std::exception& e) {
51888       {
51889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51890       };
51891     } catch (Dali::DaliException e) {
51892       {
51893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51894       };
51895     } catch (...) {
51896       {
51897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51898       };
51899     }
51900   }
51901
51902   jresult = (void *)result;
51903   return jresult;
51904 }
51905
51906
51907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51908   void * jresult ;
51909   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51910   Dali::Vector< float >::SizeType arg2 ;
51911   Dali::Vector< float >::ItemType *result = 0 ;
51912
51913   arg1 = (Dali::Vector< float > *)jarg1;
51914   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51915   {
51916     try {
51917       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51918     } catch (std::out_of_range& e) {
51919       {
51920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51921       };
51922     } catch (std::exception& e) {
51923       {
51924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51925       };
51926     } catch (Dali::DaliException e) {
51927       {
51928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51929       };
51930     } catch (...) {
51931       {
51932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51933       };
51934     }
51935   }
51936
51937   jresult = (void *)result;
51938   return jresult;
51939 }
51940
51941
51942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51943   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51944   Dali::Vector< float >::ItemType *arg2 = 0 ;
51945   Dali::Vector< float >::ItemType temp2 ;
51946
51947   arg1 = (Dali::Vector< float > *)jarg1;
51948   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51949   arg2 = &temp2;
51950   {
51951     try {
51952       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51953     } catch (std::out_of_range& e) {
51954       {
51955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51956       };
51957     } catch (std::exception& e) {
51958       {
51959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51960       };
51961     } catch (Dali::DaliException e) {
51962       {
51963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51964       };
51965     } catch (...) {
51966       {
51967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51968       };
51969     }
51970   }
51971
51972 }
51973
51974
51975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51976   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51977   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51978   Dali::Vector< float >::ItemType *arg3 = 0 ;
51979   Dali::Vector< float >::ItemType temp3 ;
51980
51981   arg1 = (Dali::Vector< float > *)jarg1;
51982   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51983   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51984   arg3 = &temp3;
51985   {
51986     try {
51987       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51988     } catch (std::out_of_range& e) {
51989       {
51990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51991       };
51992     } catch (std::exception& e) {
51993       {
51994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51995       };
51996     } catch (Dali::DaliException e) {
51997       {
51998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51999       };
52000     } catch (...) {
52001       {
52002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52003       };
52004     }
52005   }
52006
52007 }
52008
52009
52010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52011   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52012   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52013   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52014   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52015
52016   arg1 = (Dali::Vector< float > *)jarg1;
52017   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52018   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52019   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52020   {
52021     try {
52022       (arg1)->Insert(arg2,arg3,arg4);
52023     } catch (std::out_of_range& e) {
52024       {
52025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52026       };
52027     } catch (std::exception& e) {
52028       {
52029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52030       };
52031     } catch (Dali::DaliException e) {
52032       {
52033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52034       };
52035     } catch (...) {
52036       {
52037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52038       };
52039     }
52040   }
52041
52042 }
52043
52044
52045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52046   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52047   Dali::Vector< float >::SizeType arg2 ;
52048
52049   arg1 = (Dali::Vector< float > *)jarg1;
52050   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52051   {
52052     try {
52053       (arg1)->Reserve(arg2);
52054     } catch (std::out_of_range& e) {
52055       {
52056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52057       };
52058     } catch (std::exception& e) {
52059       {
52060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52061       };
52062     } catch (Dali::DaliException e) {
52063       {
52064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52065       };
52066     } catch (...) {
52067       {
52068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52069       };
52070     }
52071   }
52072
52073 }
52074
52075 //// ========================= end of part 2 =============================
52076
52077 //// ========================== start part 3 ===============================
52078
52079
52080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52081   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52082   Dali::Vector< float >::SizeType arg2 ;
52083
52084   arg1 = (Dali::Vector< float > *)jarg1;
52085   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52086   {
52087     try {
52088       (arg1)->Resize(arg2);
52089     } catch (std::out_of_range& e) {
52090       {
52091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52092       };
52093     } catch (std::exception& e) {
52094       {
52095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52096       };
52097     } catch (Dali::DaliException e) {
52098       {
52099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52100       };
52101     } catch (...) {
52102       {
52103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52104       };
52105     }
52106   }
52107
52108 }
52109
52110
52111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52112   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52113   Dali::Vector< float >::SizeType arg2 ;
52114   Dali::Vector< float >::ItemType *arg3 = 0 ;
52115   Dali::Vector< float >::ItemType temp3 ;
52116
52117   arg1 = (Dali::Vector< float > *)jarg1;
52118   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52119   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52120   arg3 = &temp3;
52121   {
52122     try {
52123       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52124     } catch (std::out_of_range& e) {
52125       {
52126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52127       };
52128     } catch (std::exception& e) {
52129       {
52130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52131       };
52132     } catch (Dali::DaliException e) {
52133       {
52134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52135       };
52136     } catch (...) {
52137       {
52138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52139       };
52140     }
52141   }
52142
52143 }
52144
52145
52146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52147   void * jresult ;
52148   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52149   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52150   Dali::Vector< float >::Iterator result;
52151
52152   arg1 = (Dali::Vector< float > *)jarg1;
52153   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52154   {
52155     try {
52156       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52157     } catch (std::out_of_range& e) {
52158       {
52159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52160       };
52161     } catch (std::exception& e) {
52162       {
52163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52164       };
52165     } catch (Dali::DaliException e) {
52166       {
52167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52168       };
52169     } catch (...) {
52170       {
52171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52172       };
52173     }
52174   }
52175
52176   jresult = (void *)result;
52177   return jresult;
52178 }
52179
52180
52181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52182   void * jresult ;
52183   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52184   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52185   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52186   Dali::Vector< float >::Iterator result;
52187
52188   arg1 = (Dali::Vector< float > *)jarg1;
52189   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52190   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52191   {
52192     try {
52193       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52194     } catch (std::out_of_range& e) {
52195       {
52196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52197       };
52198     } catch (std::exception& e) {
52199       {
52200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52201       };
52202     } catch (Dali::DaliException e) {
52203       {
52204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52205       };
52206     } catch (...) {
52207       {
52208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52209       };
52210     }
52211   }
52212
52213   jresult = (void *)result;
52214   return jresult;
52215 }
52216
52217
52218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52219   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52220   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52221
52222   arg1 = (Dali::Vector< float > *)jarg1;
52223   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52224   {
52225     try {
52226       (arg1)->Remove(arg2);
52227     } catch (std::out_of_range& e) {
52228       {
52229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52230       };
52231     } catch (std::exception& e) {
52232       {
52233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52234       };
52235     } catch (Dali::DaliException e) {
52236       {
52237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52238       };
52239     } catch (...) {
52240       {
52241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52242       };
52243     }
52244   }
52245
52246 }
52247
52248
52249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52250   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52251   Dali::Vector< float > *arg2 = 0 ;
52252
52253   arg1 = (Dali::Vector< float > *)jarg1;
52254   arg2 = (Dali::Vector< float > *)jarg2;
52255   if (!arg2) {
52256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52257     return ;
52258   }
52259   {
52260     try {
52261       (arg1)->Swap(*arg2);
52262     } catch (std::out_of_range& e) {
52263       {
52264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52265       };
52266     } catch (std::exception& e) {
52267       {
52268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52269       };
52270     } catch (Dali::DaliException e) {
52271       {
52272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52273       };
52274     } catch (...) {
52275       {
52276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52277       };
52278     }
52279   }
52280
52281 }
52282
52283
52284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52285   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52286
52287   arg1 = (Dali::Vector< float > *)jarg1;
52288   {
52289     try {
52290       (arg1)->Clear();
52291     } catch (std::out_of_range& e) {
52292       {
52293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52294       };
52295     } catch (std::exception& e) {
52296       {
52297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52298       };
52299     } catch (Dali::DaliException e) {
52300       {
52301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52302       };
52303     } catch (...) {
52304       {
52305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52306       };
52307     }
52308   }
52309
52310 }
52311
52312
52313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52314   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52315
52316   arg1 = (Dali::Vector< float > *)jarg1;
52317   {
52318     try {
52319       (arg1)->Release();
52320     } catch (std::out_of_range& e) {
52321       {
52322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52323       };
52324     } catch (std::exception& e) {
52325       {
52326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52327       };
52328     } catch (Dali::DaliException e) {
52329       {
52330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52331       };
52332     } catch (...) {
52333       {
52334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52335       };
52336     }
52337   }
52338
52339 }
52340
52341
52342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52343   int jresult ;
52344   int result;
52345
52346   result = (int)Dali::Vector< unsigned char >::BaseType;
52347   jresult = (int)result;
52348   return jresult;
52349 }
52350
52351
52352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52353   void * jresult ;
52354   Dali::Vector< unsigned char > *result = 0 ;
52355
52356   {
52357     try {
52358       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52359     } catch (std::out_of_range& e) {
52360       {
52361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52362       };
52363     } catch (std::exception& e) {
52364       {
52365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52366       };
52367     } catch (Dali::DaliException e) {
52368       {
52369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52370       };
52371     } catch (...) {
52372       {
52373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52374       };
52375     }
52376   }
52377
52378   jresult = (void *)result;
52379   return jresult;
52380 }
52381
52382
52383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52384   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52385
52386   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52387   {
52388     try {
52389       delete arg1;
52390     } catch (std::out_of_range& e) {
52391       {
52392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52393       };
52394     } catch (std::exception& e) {
52395       {
52396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52397       };
52398     } catch (Dali::DaliException e) {
52399       {
52400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52401       };
52402     } catch (...) {
52403       {
52404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52405       };
52406     }
52407   }
52408
52409 }
52410
52411
52412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52413   void * jresult ;
52414   Dali::Vector< unsigned char > *arg1 = 0 ;
52415   Dali::Vector< unsigned char > *result = 0 ;
52416
52417   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52418   if (!arg1) {
52419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52420     return 0;
52421   }
52422   {
52423     try {
52424       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52425     } catch (std::out_of_range& e) {
52426       {
52427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52428       };
52429     } catch (std::exception& e) {
52430       {
52431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52432       };
52433     } catch (Dali::DaliException e) {
52434       {
52435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52436       };
52437     } catch (...) {
52438       {
52439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52440       };
52441     }
52442   }
52443
52444   jresult = (void *)result;
52445   return jresult;
52446 }
52447
52448
52449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52450   void * jresult ;
52451   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52452   Dali::Vector< unsigned char > *arg2 = 0 ;
52453   Dali::Vector< unsigned char > *result = 0 ;
52454
52455   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52456   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52457   if (!arg2) {
52458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52459     return 0;
52460   }
52461   {
52462     try {
52463       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52464     } catch (std::out_of_range& e) {
52465       {
52466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52467       };
52468     } catch (std::exception& e) {
52469       {
52470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52471       };
52472     } catch (Dali::DaliException e) {
52473       {
52474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52475       };
52476     } catch (...) {
52477       {
52478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52479       };
52480     }
52481   }
52482
52483   jresult = (void *)result;
52484   return jresult;
52485 }
52486
52487
52488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52489   void * jresult ;
52490   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52491   Dali::Vector< unsigned char >::Iterator result;
52492
52493   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52494   {
52495     try {
52496       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52497     } catch (std::out_of_range& e) {
52498       {
52499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52500       };
52501     } catch (std::exception& e) {
52502       {
52503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52504       };
52505     } catch (Dali::DaliException e) {
52506       {
52507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52508       };
52509     } catch (...) {
52510       {
52511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52512       };
52513     }
52514   }
52515
52516   jresult = (void *)result;
52517   return jresult;
52518 }
52519
52520
52521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52522   void * jresult ;
52523   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52524   Dali::Vector< unsigned char >::Iterator result;
52525
52526   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52527   {
52528     try {
52529       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52530     } catch (std::out_of_range& e) {
52531       {
52532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52533       };
52534     } catch (std::exception& e) {
52535       {
52536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52537       };
52538     } catch (Dali::DaliException e) {
52539       {
52540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52541       };
52542     } catch (...) {
52543       {
52544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52545       };
52546     }
52547   }
52548
52549   jresult = (void *)result;
52550   return jresult;
52551 }
52552
52553
52554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52555   void * jresult ;
52556   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52557   Dali::Vector< unsigned char >::SizeType arg2 ;
52558   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52559
52560   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52561   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52562   {
52563     try {
52564       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52565     } catch (std::out_of_range& e) {
52566       {
52567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52568       };
52569     } catch (std::exception& e) {
52570       {
52571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52572       };
52573     } catch (Dali::DaliException e) {
52574       {
52575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52576       };
52577     } catch (...) {
52578       {
52579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52580       };
52581     }
52582   }
52583
52584   jresult = (void *)result;
52585   return jresult;
52586 }
52587
52588
52589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52590   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52591   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52592   Dali::Vector< unsigned char >::ItemType temp2 ;
52593
52594   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52595   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52596   arg2 = &temp2;
52597   {
52598     try {
52599       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52600     } catch (std::out_of_range& e) {
52601       {
52602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52603       };
52604     } catch (std::exception& e) {
52605       {
52606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52607       };
52608     } catch (Dali::DaliException e) {
52609       {
52610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52611       };
52612     } catch (...) {
52613       {
52614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52615       };
52616     }
52617   }
52618
52619 }
52620
52621
52622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52623   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52624   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52625   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52626   Dali::Vector< unsigned char >::ItemType temp3 ;
52627
52628   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52629   arg2 = jarg2;
52630   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52631   arg3 = &temp3;
52632   {
52633     try {
52634       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52635     } catch (std::out_of_range& e) {
52636       {
52637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52638       };
52639     } catch (std::exception& e) {
52640       {
52641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52642       };
52643     } catch (Dali::DaliException e) {
52644       {
52645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52646       };
52647     } catch (...) {
52648       {
52649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52650       };
52651     }
52652   }
52653
52654
52655
52656 }
52657
52658
52659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52660   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52661   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52662   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52663   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52664
52665   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52666   arg2 = jarg2;
52667   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52668   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52669   {
52670     try {
52671       (arg1)->Insert(arg2,arg3,arg4);
52672     } catch (std::out_of_range& e) {
52673       {
52674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52675       };
52676     } catch (std::exception& e) {
52677       {
52678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52679       };
52680     } catch (Dali::DaliException e) {
52681       {
52682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52683       };
52684     } catch (...) {
52685       {
52686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52687       };
52688     }
52689   }
52690
52691
52692
52693 }
52694
52695
52696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52697   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52698   Dali::Vector< unsigned char >::SizeType arg2 ;
52699
52700   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52701   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52702   {
52703     try {
52704       (arg1)->Reserve(arg2);
52705     } catch (std::out_of_range& e) {
52706       {
52707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52708       };
52709     } catch (std::exception& e) {
52710       {
52711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52712       };
52713     } catch (Dali::DaliException e) {
52714       {
52715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52716       };
52717     } catch (...) {
52718       {
52719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52720       };
52721     }
52722   }
52723
52724 }
52725
52726
52727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52728   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52729   Dali::Vector< unsigned char >::SizeType arg2 ;
52730
52731   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52732   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52733   {
52734     try {
52735       (arg1)->Resize(arg2);
52736     } catch (std::out_of_range& e) {
52737       {
52738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52739       };
52740     } catch (std::exception& e) {
52741       {
52742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52743       };
52744     } catch (Dali::DaliException e) {
52745       {
52746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52747       };
52748     } catch (...) {
52749       {
52750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52751       };
52752     }
52753   }
52754
52755 }
52756
52757
52758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52759   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52760   Dali::Vector< unsigned char >::SizeType arg2 ;
52761   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52762   Dali::Vector< unsigned char >::ItemType temp3 ;
52763
52764   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52765   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52766   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52767   arg3 = &temp3;
52768   {
52769     try {
52770       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52771     } catch (std::out_of_range& e) {
52772       {
52773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52774       };
52775     } catch (std::exception& e) {
52776       {
52777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52778       };
52779     } catch (Dali::DaliException e) {
52780       {
52781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52782       };
52783     } catch (...) {
52784       {
52785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52786       };
52787     }
52788   }
52789
52790 }
52791
52792
52793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52794   void * jresult ;
52795   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52796   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52797   Dali::Vector< unsigned char >::Iterator result;
52798
52799   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52800   arg2 = jarg2;
52801   {
52802     try {
52803       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52804     } catch (std::out_of_range& e) {
52805       {
52806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52807       };
52808     } catch (std::exception& e) {
52809       {
52810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52811       };
52812     } catch (Dali::DaliException e) {
52813       {
52814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52815       };
52816     } catch (...) {
52817       {
52818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52819       };
52820     }
52821   }
52822
52823   jresult = (void *)result;
52824
52825
52826   return jresult;
52827 }
52828
52829
52830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52831   void * jresult ;
52832   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52833   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52834   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52835   Dali::Vector< unsigned char >::Iterator result;
52836
52837   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52838   arg2 = jarg2;
52839   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52840   {
52841     try {
52842       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52843     } catch (std::out_of_range& e) {
52844       {
52845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52846       };
52847     } catch (std::exception& e) {
52848       {
52849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52850       };
52851     } catch (Dali::DaliException e) {
52852       {
52853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52854       };
52855     } catch (...) {
52856       {
52857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52858       };
52859     }
52860   }
52861
52862   jresult = (void *)result;
52863
52864
52865   return jresult;
52866 }
52867
52868
52869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52870   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52871   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52872
52873   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52874   arg2 = jarg2;
52875   {
52876     try {
52877       (arg1)->Remove(arg2);
52878     } catch (std::out_of_range& e) {
52879       {
52880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52881       };
52882     } catch (std::exception& e) {
52883       {
52884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52885       };
52886     } catch (Dali::DaliException e) {
52887       {
52888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52889       };
52890     } catch (...) {
52891       {
52892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52893       };
52894     }
52895   }
52896
52897
52898
52899 }
52900
52901
52902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52903   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52904   Dali::Vector< unsigned char > *arg2 = 0 ;
52905
52906   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52907   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52908   if (!arg2) {
52909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52910     return ;
52911   }
52912   {
52913     try {
52914       (arg1)->Swap(*arg2);
52915     } catch (std::out_of_range& e) {
52916       {
52917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52918       };
52919     } catch (std::exception& e) {
52920       {
52921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52922       };
52923     } catch (Dali::DaliException e) {
52924       {
52925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52926       };
52927     } catch (...) {
52928       {
52929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52930       };
52931     }
52932   }
52933
52934 }
52935
52936
52937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52938   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52939
52940   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52941   {
52942     try {
52943       (arg1)->Clear();
52944     } catch (std::out_of_range& e) {
52945       {
52946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52947       };
52948     } catch (std::exception& e) {
52949       {
52950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52951       };
52952     } catch (Dali::DaliException e) {
52953       {
52954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52955       };
52956     } catch (...) {
52957       {
52958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52959       };
52960     }
52961   }
52962
52963 }
52964
52965
52966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52967   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52968
52969   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52970   {
52971     try {
52972       (arg1)->Release();
52973     } catch (std::out_of_range& e) {
52974       {
52975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52976       };
52977     } catch (std::exception& e) {
52978       {
52979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52980       };
52981     } catch (Dali::DaliException e) {
52982       {
52983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52984       };
52985     } catch (...) {
52986       {
52987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52988       };
52989     }
52990   }
52991
52992 }
52993
52994
52995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52996   int jresult ;
52997   int result;
52998
52999   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53000   jresult = (int)result;
53001   return jresult;
53002 }
53003
53004
53005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53006   void * jresult ;
53007   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53008
53009   {
53010     try {
53011       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53012     } catch (std::out_of_range& e) {
53013       {
53014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53015       };
53016     } catch (std::exception& e) {
53017       {
53018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53019       };
53020     } catch (Dali::DaliException e) {
53021       {
53022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53023       };
53024     } catch (...) {
53025       {
53026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53027       };
53028     }
53029   }
53030
53031   jresult = (void *)result;
53032   return jresult;
53033 }
53034
53035
53036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53037   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53038
53039   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53040   {
53041     try {
53042       delete arg1;
53043     } catch (std::out_of_range& e) {
53044       {
53045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53046       };
53047     } catch (std::exception& e) {
53048       {
53049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53050       };
53051     } catch (Dali::DaliException e) {
53052       {
53053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53054       };
53055     } catch (...) {
53056       {
53057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53058       };
53059     }
53060   }
53061
53062 }
53063
53064
53065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53066   void * jresult ;
53067   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53068   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53069
53070   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53071   if (!arg1) {
53072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53073     return 0;
53074   }
53075   {
53076     try {
53077       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53078     } catch (std::out_of_range& e) {
53079       {
53080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53081       };
53082     } catch (std::exception& e) {
53083       {
53084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53085       };
53086     } catch (Dali::DaliException e) {
53087       {
53088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53089       };
53090     } catch (...) {
53091       {
53092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53093       };
53094     }
53095   }
53096
53097   jresult = (void *)result;
53098   return jresult;
53099 }
53100
53101
53102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53103   void * jresult ;
53104   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53105   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53106   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53107
53108   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53109   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53110   if (!arg2) {
53111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53112     return 0;
53113   }
53114   {
53115     try {
53116       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53117     } catch (std::out_of_range& e) {
53118       {
53119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53120       };
53121     } catch (std::exception& e) {
53122       {
53123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53124       };
53125     } catch (Dali::DaliException e) {
53126       {
53127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53128       };
53129     } catch (...) {
53130       {
53131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53132       };
53133     }
53134   }
53135
53136   jresult = (void *)result;
53137   return jresult;
53138 }
53139
53140
53141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53142   void * jresult ;
53143   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53144   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53145
53146   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53147   {
53148     try {
53149       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53150     } catch (std::out_of_range& e) {
53151       {
53152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53153       };
53154     } catch (std::exception& e) {
53155       {
53156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53157       };
53158     } catch (Dali::DaliException e) {
53159       {
53160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53161       };
53162     } catch (...) {
53163       {
53164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53165       };
53166     }
53167   }
53168
53169   jresult = (void *)result;
53170   return jresult;
53171 }
53172
53173
53174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53175   void * jresult ;
53176   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53177   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53178
53179   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53180   {
53181     try {
53182       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53183     } catch (std::out_of_range& e) {
53184       {
53185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53186       };
53187     } catch (std::exception& e) {
53188       {
53189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53190       };
53191     } catch (Dali::DaliException e) {
53192       {
53193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53194       };
53195     } catch (...) {
53196       {
53197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53198       };
53199     }
53200   }
53201
53202   jresult = (void *)result;
53203   return jresult;
53204 }
53205
53206
53207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53208   void * jresult ;
53209   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53210   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53211   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53212
53213   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53214   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53215   {
53216     try {
53217       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53218     } catch (std::out_of_range& e) {
53219       {
53220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53221       };
53222     } catch (std::exception& e) {
53223       {
53224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53225       };
53226     } catch (Dali::DaliException e) {
53227       {
53228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53229       };
53230     } catch (...) {
53231       {
53232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53233       };
53234     }
53235   }
53236
53237   jresult = (void *)result;
53238   return jresult;
53239 }
53240
53241
53242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53243   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53244   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53245
53246   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53247   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53248   if (!arg2) {
53249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53250     return ;
53251   }
53252   {
53253     try {
53254       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53255     } catch (std::out_of_range& e) {
53256       {
53257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53258       };
53259     } catch (std::exception& e) {
53260       {
53261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53262       };
53263     } catch (Dali::DaliException e) {
53264       {
53265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53266       };
53267     } catch (...) {
53268       {
53269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53270       };
53271     }
53272   }
53273
53274 }
53275
53276
53277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53278   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53279   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53280   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53281
53282   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53283   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53284   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53285   if (!arg3) {
53286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53287     return ;
53288   }
53289   {
53290     try {
53291       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53292     } catch (std::out_of_range& e) {
53293       {
53294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53295       };
53296     } catch (std::exception& e) {
53297       {
53298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53299       };
53300     } catch (Dali::DaliException e) {
53301       {
53302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53303       };
53304     } catch (...) {
53305       {
53306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53307       };
53308     }
53309   }
53310
53311 }
53312
53313
53314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53315   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53316   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53317   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53318   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53319
53320   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53321   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53322   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53323   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53324   {
53325     try {
53326       (arg1)->Insert(arg2,arg3,arg4);
53327     } catch (std::out_of_range& e) {
53328       {
53329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53330       };
53331     } catch (std::exception& e) {
53332       {
53333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53334       };
53335     } catch (Dali::DaliException e) {
53336       {
53337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53338       };
53339     } catch (...) {
53340       {
53341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53342       };
53343     }
53344   }
53345
53346 }
53347
53348
53349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53350   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53351   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53352
53353   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53354   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53355   {
53356     try {
53357       (arg1)->Reserve(arg2);
53358     } catch (std::out_of_range& e) {
53359       {
53360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53361       };
53362     } catch (std::exception& e) {
53363       {
53364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53365       };
53366     } catch (Dali::DaliException e) {
53367       {
53368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53369       };
53370     } catch (...) {
53371       {
53372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53373       };
53374     }
53375   }
53376
53377 }
53378
53379
53380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53381   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53382   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53383
53384   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53385   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53386   {
53387     try {
53388       (arg1)->Resize(arg2);
53389     } catch (std::out_of_range& e) {
53390       {
53391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53392       };
53393     } catch (std::exception& e) {
53394       {
53395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53396       };
53397     } catch (Dali::DaliException e) {
53398       {
53399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53400       };
53401     } catch (...) {
53402       {
53403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53404       };
53405     }
53406   }
53407
53408 }
53409
53410
53411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53412   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53413   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53414   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53415
53416   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53417   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53418   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53419   if (!arg3) {
53420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53421     return ;
53422   }
53423   {
53424     try {
53425       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53426     } catch (std::out_of_range& e) {
53427       {
53428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53429       };
53430     } catch (std::exception& e) {
53431       {
53432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53433       };
53434     } catch (Dali::DaliException e) {
53435       {
53436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53437       };
53438     } catch (...) {
53439       {
53440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53441       };
53442     }
53443   }
53444
53445 }
53446
53447
53448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53449   void * jresult ;
53450   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53451   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53452   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53453
53454   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53455   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53456   {
53457     try {
53458       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53459     } catch (std::out_of_range& e) {
53460       {
53461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53462       };
53463     } catch (std::exception& e) {
53464       {
53465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53466       };
53467     } catch (Dali::DaliException e) {
53468       {
53469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53470       };
53471     } catch (...) {
53472       {
53473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53474       };
53475     }
53476   }
53477
53478   jresult = (void *)result;
53479   return jresult;
53480 }
53481
53482
53483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53484   void * jresult ;
53485   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53486   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53487   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53488   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53489
53490   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53491   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53492   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53493   {
53494     try {
53495       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53496     } catch (std::out_of_range& e) {
53497       {
53498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53499       };
53500     } catch (std::exception& e) {
53501       {
53502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53503       };
53504     } catch (Dali::DaliException e) {
53505       {
53506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53507       };
53508     } catch (...) {
53509       {
53510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53511       };
53512     }
53513   }
53514
53515   jresult = (void *)result;
53516   return jresult;
53517 }
53518
53519
53520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53521   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53522   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53523
53524   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53525   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53526   {
53527     try {
53528       (arg1)->Remove(arg2);
53529     } catch (std::out_of_range& e) {
53530       {
53531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53532       };
53533     } catch (std::exception& e) {
53534       {
53535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53536       };
53537     } catch (Dali::DaliException e) {
53538       {
53539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53540       };
53541     } catch (...) {
53542       {
53543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53544       };
53545     }
53546   }
53547
53548 }
53549
53550
53551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53552   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53553   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53554
53555   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53556   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53557   if (!arg2) {
53558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53559     return ;
53560   }
53561   {
53562     try {
53563       (arg1)->Swap(*arg2);
53564     } catch (std::out_of_range& e) {
53565       {
53566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53567       };
53568     } catch (std::exception& e) {
53569       {
53570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53571       };
53572     } catch (Dali::DaliException e) {
53573       {
53574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53575       };
53576     } catch (...) {
53577       {
53578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53579       };
53580     }
53581   }
53582
53583 }
53584
53585
53586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53587   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53588
53589   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53590   {
53591     try {
53592       (arg1)->Clear();
53593     } catch (std::out_of_range& e) {
53594       {
53595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53596       };
53597     } catch (std::exception& e) {
53598       {
53599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53600       };
53601     } catch (Dali::DaliException e) {
53602       {
53603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53604       };
53605     } catch (...) {
53606       {
53607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53608       };
53609     }
53610   }
53611
53612 }
53613
53614
53615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53616   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53617
53618   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53619   {
53620     try {
53621       (arg1)->Release();
53622     } catch (std::out_of_range& e) {
53623       {
53624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53625       };
53626     } catch (std::exception& e) {
53627       {
53628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53629       };
53630     } catch (Dali::DaliException e) {
53631       {
53632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53633       };
53634     } catch (...) {
53635       {
53636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53637       };
53638     }
53639   }
53640
53641 }
53642
53643
53644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53645   void * jresult ;
53646   Dali::Signal< void () > *result = 0 ;
53647
53648   {
53649     try {
53650       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53651     } catch (std::out_of_range& e) {
53652       {
53653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53654       };
53655     } catch (std::exception& e) {
53656       {
53657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53658       };
53659     } catch (Dali::DaliException e) {
53660       {
53661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53662       };
53663     } catch (...) {
53664       {
53665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53666       };
53667     }
53668   }
53669
53670   jresult = (void *)result;
53671   return jresult;
53672 }
53673
53674
53675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53676   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53677
53678   arg1 = (Dali::Signal< void () > *)jarg1;
53679   {
53680     try {
53681       delete arg1;
53682     } catch (std::out_of_range& e) {
53683       {
53684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53685       };
53686     } catch (std::exception& e) {
53687       {
53688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53689       };
53690     } catch (Dali::DaliException e) {
53691       {
53692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53693       };
53694     } catch (...) {
53695       {
53696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53697       };
53698     }
53699   }
53700
53701 }
53702
53703
53704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53705   unsigned int jresult ;
53706   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53707   bool result;
53708
53709   arg1 = (Dali::Signal< void () > *)jarg1;
53710   {
53711     try {
53712       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53713     } catch (std::out_of_range& e) {
53714       {
53715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53716       };
53717     } catch (std::exception& e) {
53718       {
53719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53720       };
53721     } catch (Dali::DaliException e) {
53722       {
53723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53724       };
53725     } catch (...) {
53726       {
53727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53728       };
53729     }
53730   }
53731
53732   jresult = result;
53733   return jresult;
53734 }
53735
53736
53737 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53738   unsigned long jresult ;
53739   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53740   std::size_t result;
53741
53742   arg1 = (Dali::Signal< void () > *)jarg1;
53743   {
53744     try {
53745       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53746     } catch (std::out_of_range& e) {
53747       {
53748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53749       };
53750     } catch (std::exception& e) {
53751       {
53752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53753       };
53754     } catch (Dali::DaliException e) {
53755       {
53756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53757       };
53758     } catch (...) {
53759       {
53760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53761       };
53762     }
53763   }
53764
53765   jresult = (unsigned long)result;
53766   return jresult;
53767 }
53768
53769
53770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53771   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53772   void (*arg2)() = (void (*)()) 0 ;
53773
53774   arg1 = (Dali::Signal< void () > *)jarg1;
53775   arg2 = (void (*)())jarg2;
53776   {
53777     try {
53778       (arg1)->Connect(arg2);
53779     } catch (std::out_of_range& e) {
53780       {
53781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53782       };
53783     } catch (std::exception& e) {
53784       {
53785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53786       };
53787     } catch (Dali::DaliException e) {
53788       {
53789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53790       };
53791     } catch (...) {
53792       {
53793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53794       };
53795     }
53796   }
53797
53798 }
53799
53800
53801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53802   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53803   void (*arg2)() = (void (*)()) 0 ;
53804
53805   arg1 = (Dali::Signal< void () > *)jarg1;
53806   arg2 = (void (*)())jarg2;
53807   {
53808     try {
53809       (arg1)->Disconnect(arg2);
53810     } catch (std::out_of_range& e) {
53811       {
53812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53813       };
53814     } catch (std::exception& e) {
53815       {
53816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53817       };
53818     } catch (Dali::DaliException e) {
53819       {
53820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53821       };
53822     } catch (...) {
53823       {
53824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53825       };
53826     }
53827   }
53828
53829 }
53830
53831
53832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53833   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53834   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53835   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53836
53837   arg1 = (Dali::Signal< void () > *)jarg1;
53838   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53839   arg3 = (Dali::FunctorDelegate *)jarg3;
53840   {
53841     try {
53842       (arg1)->Connect(arg2,arg3);
53843     } catch (std::out_of_range& e) {
53844       {
53845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53846       };
53847     } catch (std::exception& e) {
53848       {
53849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53850       };
53851     } catch (Dali::DaliException e) {
53852       {
53853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53854       };
53855     } catch (...) {
53856       {
53857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53858       };
53859     }
53860   }
53861
53862 }
53863
53864
53865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53866   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53867
53868   arg1 = (Dali::Signal< void () > *)jarg1;
53869   {
53870     try {
53871       (arg1)->Emit();
53872     } catch (std::out_of_range& e) {
53873       {
53874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53875       };
53876     } catch (std::exception& e) {
53877       {
53878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53879       };
53880     } catch (Dali::DaliException e) {
53881       {
53882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53883       };
53884     } catch (...) {
53885       {
53886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53887       };
53888     }
53889   }
53890
53891 }
53892
53893
53894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53895   unsigned int jresult ;
53896   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53897   bool result;
53898
53899   arg1 = (Dali::Signal< void (float) > *)jarg1;
53900   {
53901     try {
53902       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53903     } catch (std::out_of_range& e) {
53904       {
53905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53906       };
53907     } catch (std::exception& e) {
53908       {
53909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53910       };
53911     } catch (Dali::DaliException e) {
53912       {
53913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53914       };
53915     } catch (...) {
53916       {
53917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53918       };
53919     }
53920   }
53921
53922   jresult = result;
53923   return jresult;
53924 }
53925
53926
53927 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53928   unsigned long jresult ;
53929   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53930   std::size_t result;
53931
53932   arg1 = (Dali::Signal< void (float) > *)jarg1;
53933   {
53934     try {
53935       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53936     } catch (std::out_of_range& e) {
53937       {
53938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53939       };
53940     } catch (std::exception& e) {
53941       {
53942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53943       };
53944     } catch (Dali::DaliException e) {
53945       {
53946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53947       };
53948     } catch (...) {
53949       {
53950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53951       };
53952     }
53953   }
53954
53955   jresult = (unsigned long)result;
53956   return jresult;
53957 }
53958
53959
53960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53961   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53962   void (*arg2)(float) = (void (*)(float)) 0 ;
53963
53964   arg1 = (Dali::Signal< void (float) > *)jarg1;
53965   arg2 = (void (*)(float))jarg2;
53966   {
53967     try {
53968       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53969     } catch (std::out_of_range& e) {
53970       {
53971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53972       };
53973     } catch (std::exception& e) {
53974       {
53975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53976       };
53977     } catch (Dali::DaliException e) {
53978       {
53979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53980       };
53981     } catch (...) {
53982       {
53983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53984       };
53985     }
53986   }
53987
53988 }
53989
53990
53991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53992   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53993   void (*arg2)(float) = (void (*)(float)) 0 ;
53994
53995   arg1 = (Dali::Signal< void (float) > *)jarg1;
53996   arg2 = (void (*)(float))jarg2;
53997   {
53998     try {
53999       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54000     } catch (std::out_of_range& e) {
54001       {
54002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54003       };
54004     } catch (std::exception& e) {
54005       {
54006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54007       };
54008     } catch (Dali::DaliException e) {
54009       {
54010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54011       };
54012     } catch (...) {
54013       {
54014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54015       };
54016     }
54017   }
54018
54019 }
54020
54021
54022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54023   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54024   float arg2 ;
54025
54026   arg1 = (Dali::Signal< void (float) > *)jarg1;
54027   arg2 = (float)jarg2;
54028   {
54029     try {
54030       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54031     } catch (std::out_of_range& e) {
54032       {
54033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54034       };
54035     } catch (std::exception& e) {
54036       {
54037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54038       };
54039     } catch (Dali::DaliException e) {
54040       {
54041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54042       };
54043     } catch (...) {
54044       {
54045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54046       };
54047     }
54048   }
54049
54050 }
54051
54052
54053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54054   void * jresult ;
54055   Dali::Signal< void (float) > *result = 0 ;
54056
54057   {
54058     try {
54059       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54060     } catch (std::out_of_range& e) {
54061       {
54062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54063       };
54064     } catch (std::exception& e) {
54065       {
54066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54067       };
54068     } catch (Dali::DaliException e) {
54069       {
54070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54071       };
54072     } catch (...) {
54073       {
54074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54075       };
54076     }
54077   }
54078
54079   jresult = (void *)result;
54080   return jresult;
54081 }
54082
54083
54084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54085   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54086
54087   arg1 = (Dali::Signal< void (float) > *)jarg1;
54088   {
54089     try {
54090       delete arg1;
54091     } catch (std::out_of_range& e) {
54092       {
54093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54094       };
54095     } catch (std::exception& e) {
54096       {
54097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54098       };
54099     } catch (Dali::DaliException e) {
54100       {
54101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54102       };
54103     } catch (...) {
54104       {
54105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54106       };
54107     }
54108   }
54109
54110 }
54111
54112
54113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54114   unsigned int jresult ;
54115   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54116   bool result;
54117
54118   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54119   {
54120     try {
54121       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54122     } catch (std::out_of_range& e) {
54123       {
54124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54125       };
54126     } catch (std::exception& e) {
54127       {
54128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54129       };
54130     } catch (Dali::DaliException e) {
54131       {
54132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54133       };
54134     } catch (...) {
54135       {
54136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54137       };
54138     }
54139   }
54140
54141   jresult = result;
54142   return jresult;
54143 }
54144
54145
54146 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54147   unsigned long jresult ;
54148   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54149   std::size_t result;
54150
54151   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54152   {
54153     try {
54154       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54155     } catch (std::out_of_range& e) {
54156       {
54157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54158       };
54159     } catch (std::exception& e) {
54160       {
54161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54162       };
54163     } catch (Dali::DaliException e) {
54164       {
54165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54166       };
54167     } catch (...) {
54168       {
54169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54170       };
54171     }
54172   }
54173
54174   jresult = (unsigned long)result;
54175   return jresult;
54176 }
54177
54178
54179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54180   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54181   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54182
54183   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54184   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54185   {
54186     try {
54187       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54188     } catch (std::out_of_range& e) {
54189       {
54190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54191       };
54192     } catch (std::exception& e) {
54193       {
54194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54195       };
54196     } catch (Dali::DaliException e) {
54197       {
54198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54199       };
54200     } catch (...) {
54201       {
54202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54203       };
54204     }
54205   }
54206
54207 }
54208
54209
54210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54211   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54212   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54213
54214   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54215   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54216   {
54217     try {
54218       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54219     } catch (std::out_of_range& e) {
54220       {
54221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54222       };
54223     } catch (std::exception& e) {
54224       {
54225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54226       };
54227     } catch (Dali::DaliException e) {
54228       {
54229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54230       };
54231     } catch (...) {
54232       {
54233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54234       };
54235     }
54236   }
54237
54238 }
54239
54240
54241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54242   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54243   Dali::BaseHandle arg2 ;
54244   Dali::BaseHandle *argp2 ;
54245
54246   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54247   argp2 = (Dali::BaseHandle *)jarg2;
54248   if (!argp2) {
54249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54250     return ;
54251   }
54252   arg2 = *argp2;
54253   {
54254     try {
54255       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54256     } catch (std::out_of_range& e) {
54257       {
54258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54259       };
54260     } catch (std::exception& e) {
54261       {
54262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54263       };
54264     } catch (Dali::DaliException e) {
54265       {
54266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54267       };
54268     } catch (...) {
54269       {
54270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54271       };
54272     }
54273   }
54274
54275 }
54276
54277
54278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54279   void * jresult ;
54280   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54281
54282   {
54283     try {
54284       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54285     } catch (std::out_of_range& e) {
54286       {
54287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54288       };
54289     } catch (std::exception& e) {
54290       {
54291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54292       };
54293     } catch (Dali::DaliException e) {
54294       {
54295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54296       };
54297     } catch (...) {
54298       {
54299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54300       };
54301     }
54302   }
54303
54304   jresult = (void *)result;
54305   return jresult;
54306 }
54307
54308
54309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54310   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54311
54312   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54313   {
54314     try {
54315       delete arg1;
54316     } catch (std::out_of_range& e) {
54317       {
54318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54319       };
54320     } catch (std::exception& e) {
54321       {
54322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54323       };
54324     } catch (Dali::DaliException e) {
54325       {
54326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54327       };
54328     } catch (...) {
54329       {
54330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54331       };
54332     }
54333   }
54334
54335 }
54336
54337
54338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54339   unsigned int jresult ;
54340   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54341   bool result;
54342
54343   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54344   {
54345     try {
54346       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54347     } catch (std::out_of_range& e) {
54348       {
54349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54350       };
54351     } catch (std::exception& e) {
54352       {
54353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54354       };
54355     } catch (Dali::DaliException e) {
54356       {
54357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54358       };
54359     } catch (...) {
54360       {
54361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54362       };
54363     }
54364   }
54365
54366   jresult = result;
54367   return jresult;
54368 }
54369
54370
54371 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54372   unsigned long jresult ;
54373   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54374   std::size_t result;
54375
54376   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54377   {
54378     try {
54379       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54380     } catch (std::out_of_range& e) {
54381       {
54382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54383       };
54384     } catch (std::exception& e) {
54385       {
54386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54387       };
54388     } catch (Dali::DaliException e) {
54389       {
54390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54391       };
54392     } catch (...) {
54393       {
54394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54395       };
54396     }
54397   }
54398
54399   jresult = (unsigned long)result;
54400   return jresult;
54401 }
54402
54403
54404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54405   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54406   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54407
54408   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54409   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54410   {
54411     try {
54412       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54413     } catch (std::out_of_range& e) {
54414       {
54415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54416       };
54417     } catch (std::exception& e) {
54418       {
54419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54420       };
54421     } catch (Dali::DaliException e) {
54422       {
54423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54424       };
54425     } catch (...) {
54426       {
54427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54428       };
54429     }
54430   }
54431
54432 }
54433
54434
54435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54436   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54437   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54438
54439   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54440   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54441   {
54442     try {
54443       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54444     } catch (std::out_of_range& e) {
54445       {
54446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54447       };
54448     } catch (std::exception& e) {
54449       {
54450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54451       };
54452     } catch (Dali::DaliException e) {
54453       {
54454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54455       };
54456     } catch (...) {
54457       {
54458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54459       };
54460     }
54461   }
54462
54463 }
54464
54465
54466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54467   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54468   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54469
54470   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54471   arg2 = (Dali::RefObject *)jarg2;
54472   {
54473     try {
54474       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54475     } catch (std::out_of_range& e) {
54476       {
54477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54478       };
54479     } catch (std::exception& e) {
54480       {
54481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54482       };
54483     } catch (Dali::DaliException e) {
54484       {
54485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54486       };
54487     } catch (...) {
54488       {
54489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54490       };
54491     }
54492   }
54493
54494 }
54495
54496
54497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54498   void * jresult ;
54499   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54500
54501   {
54502     try {
54503       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54504     } catch (std::out_of_range& e) {
54505       {
54506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54507       };
54508     } catch (std::exception& e) {
54509       {
54510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54511       };
54512     } catch (Dali::DaliException e) {
54513       {
54514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54515       };
54516     } catch (...) {
54517       {
54518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54519       };
54520     }
54521   }
54522
54523   jresult = (void *)result;
54524   return jresult;
54525 }
54526
54527
54528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54529   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54530
54531   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54532   {
54533     try {
54534       delete arg1;
54535     } catch (std::out_of_range& e) {
54536       {
54537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54538       };
54539     } catch (std::exception& e) {
54540       {
54541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54542       };
54543     } catch (Dali::DaliException e) {
54544       {
54545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54546       };
54547     } catch (...) {
54548       {
54549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54550       };
54551     }
54552   }
54553
54554 }
54555
54556
54557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54558   unsigned int jresult ;
54559   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54560   bool result;
54561
54562   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54563   {
54564     try {
54565       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54566     } catch (std::out_of_range& e) {
54567       {
54568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54569       };
54570     } catch (std::exception& e) {
54571       {
54572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54573       };
54574     } catch (Dali::DaliException e) {
54575       {
54576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54577       };
54578     } catch (...) {
54579       {
54580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54581       };
54582     }
54583   }
54584
54585   jresult = result;
54586   return jresult;
54587 }
54588
54589
54590 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54591   unsigned long jresult ;
54592   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54593   std::size_t result;
54594
54595   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54596   {
54597     try {
54598       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54599     } catch (std::out_of_range& e) {
54600       {
54601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54602       };
54603     } catch (std::exception& e) {
54604       {
54605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54606       };
54607     } catch (Dali::DaliException e) {
54608       {
54609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54610       };
54611     } catch (...) {
54612       {
54613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54614       };
54615     }
54616   }
54617
54618   jresult = (unsigned long)result;
54619   return jresult;
54620 }
54621
54622
54623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54624   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54625   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54626
54627   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54628   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54629   {
54630     try {
54631       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54632     } catch (std::out_of_range& e) {
54633       {
54634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54635       };
54636     } catch (std::exception& e) {
54637       {
54638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54639       };
54640     } catch (Dali::DaliException e) {
54641       {
54642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54643       };
54644     } catch (...) {
54645       {
54646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54647       };
54648     }
54649   }
54650
54651 }
54652
54653
54654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54655   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54656   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54657
54658   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54659   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54660   {
54661     try {
54662       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54663     } catch (std::out_of_range& e) {
54664       {
54665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54666       };
54667     } catch (std::exception& e) {
54668       {
54669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54670       };
54671     } catch (Dali::DaliException e) {
54672       {
54673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54674       };
54675     } catch (...) {
54676       {
54677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54678       };
54679     }
54680   }
54681
54682 }
54683
54684
54685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54686   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54687   Dali::PropertyNotification *arg2 = 0 ;
54688
54689   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54690   arg2 = (Dali::PropertyNotification *)jarg2;
54691   if (!arg2) {
54692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54693     return ;
54694   }
54695   {
54696     try {
54697       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54698     } catch (std::out_of_range& e) {
54699       {
54700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54701       };
54702     } catch (std::exception& e) {
54703       {
54704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54705       };
54706     } catch (Dali::DaliException e) {
54707       {
54708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54709       };
54710     } catch (...) {
54711       {
54712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54713       };
54714     }
54715   }
54716
54717 }
54718
54719
54720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54721   void * jresult ;
54722   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54723
54724   {
54725     try {
54726       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54727     } catch (std::out_of_range& e) {
54728       {
54729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54730       };
54731     } catch (std::exception& e) {
54732       {
54733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54734       };
54735     } catch (Dali::DaliException e) {
54736       {
54737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54738       };
54739     } catch (...) {
54740       {
54741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54742       };
54743     }
54744   }
54745
54746   jresult = (void *)result;
54747   return jresult;
54748 }
54749
54750
54751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54752   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54753
54754   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54755   {
54756     try {
54757       delete arg1;
54758     } catch (std::out_of_range& e) {
54759       {
54760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54761       };
54762     } catch (std::exception& e) {
54763       {
54764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54765       };
54766     } catch (Dali::DaliException e) {
54767       {
54768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54769       };
54770     } catch (...) {
54771       {
54772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54773       };
54774     }
54775   }
54776
54777 }
54778
54779
54780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54781   unsigned int jresult ;
54782   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54783   bool result;
54784
54785   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54786   {
54787     try {
54788       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54789     } catch (std::out_of_range& e) {
54790       {
54791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54792       };
54793     } catch (std::exception& e) {
54794       {
54795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54796       };
54797     } catch (Dali::DaliException e) {
54798       {
54799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54800       };
54801     } catch (...) {
54802       {
54803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54804       };
54805     }
54806   }
54807
54808   jresult = result;
54809   return jresult;
54810 }
54811
54812
54813 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54814   unsigned long jresult ;
54815   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54816   std::size_t result;
54817
54818   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54819   {
54820     try {
54821       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54822     } catch (std::out_of_range& e) {
54823       {
54824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54825       };
54826     } catch (std::exception& e) {
54827       {
54828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54829       };
54830     } catch (Dali::DaliException e) {
54831       {
54832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54833       };
54834     } catch (...) {
54835       {
54836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54837       };
54838     }
54839   }
54840
54841   jresult = (unsigned long)result;
54842   return jresult;
54843 }
54844
54845
54846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54847   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54848   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54849
54850   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54851   arg2 = (void (*)(Dali::Image))jarg2;
54852   {
54853     try {
54854       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54855     } catch (std::out_of_range& e) {
54856       {
54857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54858       };
54859     } catch (std::exception& e) {
54860       {
54861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54862       };
54863     } catch (Dali::DaliException e) {
54864       {
54865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54866       };
54867     } catch (...) {
54868       {
54869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54870       };
54871     }
54872   }
54873
54874 }
54875
54876
54877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54878   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54879   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54880
54881   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54882   arg2 = (void (*)(Dali::Image))jarg2;
54883   {
54884     try {
54885       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54886     } catch (std::out_of_range& e) {
54887       {
54888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54889       };
54890     } catch (std::exception& e) {
54891       {
54892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54893       };
54894     } catch (Dali::DaliException e) {
54895       {
54896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54897       };
54898     } catch (...) {
54899       {
54900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54901       };
54902     }
54903   }
54904
54905 }
54906
54907
54908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54909   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54910   Dali::Image arg2 ;
54911   Dali::Image *argp2 ;
54912
54913   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54914   argp2 = (Dali::Image *)jarg2;
54915   if (!argp2) {
54916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54917     return ;
54918   }
54919   arg2 = *argp2;
54920   {
54921     try {
54922       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54923     } catch (std::out_of_range& e) {
54924       {
54925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54926       };
54927     } catch (std::exception& e) {
54928       {
54929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54930       };
54931     } catch (Dali::DaliException e) {
54932       {
54933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54934       };
54935     } catch (...) {
54936       {
54937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54938       };
54939     }
54940   }
54941
54942 }
54943
54944
54945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54946   void * jresult ;
54947   Dali::Signal< void (Dali::Image) > *result = 0 ;
54948
54949   {
54950     try {
54951       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54952     } catch (std::out_of_range& e) {
54953       {
54954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54955       };
54956     } catch (std::exception& e) {
54957       {
54958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54959       };
54960     } catch (Dali::DaliException e) {
54961       {
54962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54963       };
54964     } catch (...) {
54965       {
54966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54967       };
54968     }
54969   }
54970
54971   jresult = (void *)result;
54972   return jresult;
54973 }
54974
54975
54976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54977   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54978
54979   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54980   {
54981     try {
54982       delete arg1;
54983     } catch (std::out_of_range& e) {
54984       {
54985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54986       };
54987     } catch (std::exception& e) {
54988       {
54989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54990       };
54991     } catch (Dali::DaliException e) {
54992       {
54993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54994       };
54995     } catch (...) {
54996       {
54997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54998       };
54999     }
55000   }
55001
55002 }
55003
55004
55005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55006   void * jresult ;
55007   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55008
55009   {
55010     try {
55011       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55012     } catch (std::out_of_range& e) {
55013       {
55014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55015       };
55016     } catch (std::exception& e) {
55017       {
55018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55019       };
55020     } catch (Dali::DaliException e) {
55021       {
55022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55023       };
55024     } catch (...) {
55025       {
55026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55027       };
55028     }
55029   }
55030
55031   jresult = (void *)result;
55032   return jresult;
55033 }
55034
55035
55036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55037   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55038
55039   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55040   {
55041     try {
55042       delete arg1;
55043     } catch (std::out_of_range& e) {
55044       {
55045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55046       };
55047     } catch (std::exception& e) {
55048       {
55049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55050       };
55051     } catch (Dali::DaliException e) {
55052       {
55053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55054       };
55055     } catch (...) {
55056       {
55057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55058       };
55059     }
55060   }
55061
55062 }
55063
55064
55065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55066   unsigned int jresult ;
55067   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55068   bool result;
55069
55070   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55071   {
55072     try {
55073       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);
55074     } catch (std::out_of_range& e) {
55075       {
55076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55077       };
55078     } catch (std::exception& e) {
55079       {
55080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55081       };
55082     } catch (Dali::DaliException e) {
55083       {
55084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55085       };
55086     } catch (...) {
55087       {
55088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55089       };
55090     }
55091   }
55092
55093   jresult = result;
55094   return jresult;
55095 }
55096
55097
55098 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55099   unsigned long jresult ;
55100   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55101   std::size_t result;
55102
55103   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55104   {
55105     try {
55106       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);
55107     } catch (std::out_of_range& e) {
55108       {
55109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55110       };
55111     } catch (std::exception& e) {
55112       {
55113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55114       };
55115     } catch (Dali::DaliException e) {
55116       {
55117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55118       };
55119     } catch (...) {
55120       {
55121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55122       };
55123     }
55124   }
55125
55126   jresult = (unsigned long)result;
55127   return jresult;
55128 }
55129
55130
55131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55132   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55133   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55134
55135   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55136   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55137   {
55138     try {
55139       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55140     } catch (std::out_of_range& e) {
55141       {
55142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55143       };
55144     } catch (std::exception& e) {
55145       {
55146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55147       };
55148     } catch (Dali::DaliException e) {
55149       {
55150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55151       };
55152     } catch (...) {
55153       {
55154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55155       };
55156     }
55157   }
55158
55159 }
55160
55161
55162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55163   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55164   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55165
55166   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55167   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55168   {
55169     try {
55170       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55171     } catch (std::out_of_range& e) {
55172       {
55173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55174       };
55175     } catch (std::exception& e) {
55176       {
55177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55178       };
55179     } catch (Dali::DaliException e) {
55180       {
55181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55182       };
55183     } catch (...) {
55184       {
55185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55186       };
55187     }
55188   }
55189
55190 }
55191
55192
55193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55194   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55195   Dali::Actor arg2 ;
55196   Dali::LongPressGesture *arg3 = 0 ;
55197   Dali::Actor *argp2 ;
55198
55199   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55200   argp2 = (Dali::Actor *)jarg2;
55201   if (!argp2) {
55202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55203     return ;
55204   }
55205   arg2 = *argp2;
55206   arg3 = (Dali::LongPressGesture *)jarg3;
55207   if (!arg3) {
55208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55209     return ;
55210   }
55211   {
55212     try {
55213       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55214     } catch (std::out_of_range& e) {
55215       {
55216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55217       };
55218     } catch (std::exception& e) {
55219       {
55220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55221       };
55222     } catch (Dali::DaliException e) {
55223       {
55224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55225       };
55226     } catch (...) {
55227       {
55228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55229       };
55230     }
55231   }
55232
55233 }
55234
55235
55236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55237   void * jresult ;
55238   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55239
55240   {
55241     try {
55242       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55243     } catch (std::out_of_range& e) {
55244       {
55245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55246       };
55247     } catch (std::exception& e) {
55248       {
55249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55250       };
55251     } catch (Dali::DaliException e) {
55252       {
55253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55254       };
55255     } catch (...) {
55256       {
55257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55258       };
55259     }
55260   }
55261
55262   jresult = (void *)result;
55263   return jresult;
55264 }
55265
55266
55267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55268   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55269
55270   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55271   {
55272     try {
55273       delete arg1;
55274     } catch (std::out_of_range& e) {
55275       {
55276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55277       };
55278     } catch (std::exception& e) {
55279       {
55280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55281       };
55282     } catch (Dali::DaliException e) {
55283       {
55284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55285       };
55286     } catch (...) {
55287       {
55288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55289       };
55290     }
55291   }
55292
55293 }
55294
55295
55296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55297   unsigned int jresult ;
55298   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55299   bool result;
55300
55301   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55302   {
55303     try {
55304       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);
55305     } catch (std::out_of_range& e) {
55306       {
55307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55308       };
55309     } catch (std::exception& e) {
55310       {
55311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55312       };
55313     } catch (Dali::DaliException e) {
55314       {
55315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55316       };
55317     } catch (...) {
55318       {
55319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55320       };
55321     }
55322   }
55323
55324   jresult = result;
55325   return jresult;
55326 }
55327
55328
55329 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55330   unsigned long jresult ;
55331   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55332   std::size_t result;
55333
55334   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55335   {
55336     try {
55337       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);
55338     } catch (std::out_of_range& e) {
55339       {
55340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55341       };
55342     } catch (std::exception& e) {
55343       {
55344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55345       };
55346     } catch (Dali::DaliException e) {
55347       {
55348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55349       };
55350     } catch (...) {
55351       {
55352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55353       };
55354     }
55355   }
55356
55357   jresult = (unsigned long)result;
55358   return jresult;
55359 }
55360
55361
55362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55363   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55364   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55365
55366   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55367   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55368   {
55369     try {
55370       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55371     } catch (std::out_of_range& e) {
55372       {
55373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55374       };
55375     } catch (std::exception& e) {
55376       {
55377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55378       };
55379     } catch (Dali::DaliException e) {
55380       {
55381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55382       };
55383     } catch (...) {
55384       {
55385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55386       };
55387     }
55388   }
55389
55390 }
55391
55392
55393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55394   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55395   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55396
55397   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55398   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55399   {
55400     try {
55401       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55402     } catch (std::out_of_range& e) {
55403       {
55404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55405       };
55406     } catch (std::exception& e) {
55407       {
55408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55409       };
55410     } catch (Dali::DaliException e) {
55411       {
55412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55413       };
55414     } catch (...) {
55415       {
55416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55417       };
55418     }
55419   }
55420
55421 }
55422
55423
55424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55425   unsigned int jresult ;
55426   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55427   Dali::Actor arg2 ;
55428   Dali::TouchData *arg3 = 0 ;
55429   Dali::Actor *argp2 ;
55430   bool result;
55431
55432   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55433   argp2 = (Dali::Actor *)jarg2;
55434   if (!argp2) {
55435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55436     return 0;
55437   }
55438   arg2 = *argp2;
55439   arg3 = (Dali::TouchData *)jarg3;
55440   if (!arg3) {
55441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55442     return 0;
55443   }
55444   {
55445     try {
55446       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55447     } catch (std::out_of_range& e) {
55448       {
55449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55450       };
55451     } catch (std::exception& e) {
55452       {
55453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55454       };
55455     } catch (Dali::DaliException e) {
55456       {
55457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55458       };
55459     } catch (...) {
55460       {
55461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55462       };
55463     }
55464   }
55465
55466   jresult = result;
55467   return jresult;
55468 }
55469
55470
55471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55472   void * jresult ;
55473   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55474
55475   {
55476     try {
55477       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55478     } catch (std::out_of_range& e) {
55479       {
55480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55481       };
55482     } catch (std::exception& e) {
55483       {
55484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55485       };
55486     } catch (Dali::DaliException e) {
55487       {
55488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55489       };
55490     } catch (...) {
55491       {
55492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55493       };
55494     }
55495   }
55496
55497   jresult = (void *)result;
55498   return jresult;
55499 }
55500
55501
55502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55503   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55504
55505   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55506   {
55507     try {
55508       delete arg1;
55509     } catch (std::out_of_range& e) {
55510       {
55511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55512       };
55513     } catch (std::exception& e) {
55514       {
55515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55516       };
55517     } catch (Dali::DaliException e) {
55518       {
55519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55520       };
55521     } catch (...) {
55522       {
55523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55524       };
55525     }
55526   }
55527
55528 }
55529
55530
55531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55532   unsigned int jresult ;
55533   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55534   bool result;
55535
55536   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55537   {
55538     try {
55539       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);
55540     } catch (std::out_of_range& e) {
55541       {
55542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55543       };
55544     } catch (std::exception& e) {
55545       {
55546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55547       };
55548     } catch (Dali::DaliException e) {
55549       {
55550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55551       };
55552     } catch (...) {
55553       {
55554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55555       };
55556     }
55557   }
55558
55559   jresult = result;
55560   return jresult;
55561 }
55562
55563
55564 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55565   unsigned long jresult ;
55566   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55567   std::size_t result;
55568
55569   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55570   {
55571     try {
55572       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);
55573     } catch (std::out_of_range& e) {
55574       {
55575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55576       };
55577     } catch (std::exception& e) {
55578       {
55579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55580       };
55581     } catch (Dali::DaliException e) {
55582       {
55583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55584       };
55585     } catch (...) {
55586       {
55587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55588       };
55589     }
55590   }
55591
55592   jresult = (unsigned long)result;
55593   return jresult;
55594 }
55595
55596
55597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55598   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55599   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55600
55601   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55602   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55603   {
55604     try {
55605       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55606     } catch (std::out_of_range& e) {
55607       {
55608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55609       };
55610     } catch (std::exception& e) {
55611       {
55612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55613       };
55614     } catch (Dali::DaliException e) {
55615       {
55616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55617       };
55618     } catch (...) {
55619       {
55620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55621       };
55622     }
55623   }
55624
55625 }
55626
55627
55628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55629   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55630   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55631
55632   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55633   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55634   {
55635     try {
55636       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55637     } catch (std::out_of_range& e) {
55638       {
55639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55640       };
55641     } catch (std::exception& e) {
55642       {
55643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55644       };
55645     } catch (Dali::DaliException e) {
55646       {
55647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55648       };
55649     } catch (...) {
55650       {
55651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55652       };
55653     }
55654   }
55655
55656 }
55657
55658
55659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55660   unsigned int jresult ;
55661   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55662   Dali::Actor arg2 ;
55663   Dali::HoverEvent *arg3 = 0 ;
55664   Dali::Actor *argp2 ;
55665   bool result;
55666
55667   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55668   argp2 = (Dali::Actor *)jarg2;
55669   if (!argp2) {
55670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55671     return 0;
55672   }
55673   arg2 = *argp2;
55674   arg3 = (Dali::HoverEvent *)jarg3;
55675   if (!arg3) {
55676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55677     return 0;
55678   }
55679   {
55680     try {
55681       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55682     } catch (std::out_of_range& e) {
55683       {
55684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55685       };
55686     } catch (std::exception& e) {
55687       {
55688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55689       };
55690     } catch (Dali::DaliException e) {
55691       {
55692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55693       };
55694     } catch (...) {
55695       {
55696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55697       };
55698     }
55699   }
55700
55701   jresult = result;
55702   return jresult;
55703 }
55704
55705
55706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55707   void * jresult ;
55708   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55709
55710   {
55711     try {
55712       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55713     } catch (std::out_of_range& e) {
55714       {
55715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55716       };
55717     } catch (std::exception& e) {
55718       {
55719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55720       };
55721     } catch (Dali::DaliException e) {
55722       {
55723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55724       };
55725     } catch (...) {
55726       {
55727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55728       };
55729     }
55730   }
55731
55732   jresult = (void *)result;
55733   return jresult;
55734 }
55735
55736
55737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55738   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55739
55740   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55741   {
55742     try {
55743       delete arg1;
55744     } catch (std::out_of_range& e) {
55745       {
55746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55747       };
55748     } catch (std::exception& e) {
55749       {
55750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55751       };
55752     } catch (Dali::DaliException e) {
55753       {
55754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55755       };
55756     } catch (...) {
55757       {
55758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55759       };
55760     }
55761   }
55762
55763 }
55764
55765
55766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55767   unsigned int jresult ;
55768   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55769   bool result;
55770
55771   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55772   {
55773     try {
55774       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);
55775     } catch (std::out_of_range& e) {
55776       {
55777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55778       };
55779     } catch (std::exception& e) {
55780       {
55781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55782       };
55783     } catch (Dali::DaliException e) {
55784       {
55785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55786       };
55787     } catch (...) {
55788       {
55789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55790       };
55791     }
55792   }
55793
55794   jresult = result;
55795   return jresult;
55796 }
55797
55798
55799 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55800   unsigned long jresult ;
55801   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55802   std::size_t result;
55803
55804   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55805   {
55806     try {
55807       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);
55808     } catch (std::out_of_range& e) {
55809       {
55810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55811       };
55812     } catch (std::exception& e) {
55813       {
55814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55815       };
55816     } catch (Dali::DaliException e) {
55817       {
55818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55819       };
55820     } catch (...) {
55821       {
55822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55823       };
55824     }
55825   }
55826
55827   jresult = (unsigned long)result;
55828   return jresult;
55829 }
55830
55831
55832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55833   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55834   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55835
55836   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55837   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55838   {
55839     try {
55840       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55841     } catch (std::out_of_range& e) {
55842       {
55843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55844       };
55845     } catch (std::exception& e) {
55846       {
55847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55848       };
55849     } catch (Dali::DaliException e) {
55850       {
55851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55852       };
55853     } catch (...) {
55854       {
55855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55856       };
55857     }
55858   }
55859
55860 }
55861
55862
55863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55864   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55865   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55866
55867   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55868   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55869   {
55870     try {
55871       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55872     } catch (std::out_of_range& e) {
55873       {
55874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55875       };
55876     } catch (std::exception& e) {
55877       {
55878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55879       };
55880     } catch (Dali::DaliException e) {
55881       {
55882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55883       };
55884     } catch (...) {
55885       {
55886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55887       };
55888     }
55889   }
55890
55891 }
55892
55893
55894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55895   unsigned int jresult ;
55896   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55897   Dali::Actor arg2 ;
55898   Dali::WheelEvent *arg3 = 0 ;
55899   Dali::Actor *argp2 ;
55900   bool result;
55901
55902   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55903   argp2 = (Dali::Actor *)jarg2;
55904   if (!argp2) {
55905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55906     return 0;
55907   }
55908   arg2 = *argp2;
55909   arg3 = (Dali::WheelEvent *)jarg3;
55910   if (!arg3) {
55911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55912     return 0;
55913   }
55914   {
55915     try {
55916       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55917     } catch (std::out_of_range& e) {
55918       {
55919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55920       };
55921     } catch (std::exception& e) {
55922       {
55923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55924       };
55925     } catch (Dali::DaliException e) {
55926       {
55927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55928       };
55929     } catch (...) {
55930       {
55931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55932       };
55933     }
55934   }
55935
55936   jresult = result;
55937   return jresult;
55938 }
55939
55940
55941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55942   void * jresult ;
55943   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55944
55945   {
55946     try {
55947       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55948     } catch (std::out_of_range& e) {
55949       {
55950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55951       };
55952     } catch (std::exception& e) {
55953       {
55954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55955       };
55956     } catch (Dali::DaliException e) {
55957       {
55958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55959       };
55960     } catch (...) {
55961       {
55962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55963       };
55964     }
55965   }
55966
55967   jresult = (void *)result;
55968   return jresult;
55969 }
55970
55971
55972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55973   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55974
55975   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55976   {
55977     try {
55978       delete arg1;
55979     } catch (std::out_of_range& e) {
55980       {
55981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55982       };
55983     } catch (std::exception& e) {
55984       {
55985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55986       };
55987     } catch (Dali::DaliException e) {
55988       {
55989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55990       };
55991     } catch (...) {
55992       {
55993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55994       };
55995     }
55996   }
55997
55998 }
55999
56000
56001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56002   unsigned int jresult ;
56003   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56004   bool result;
56005
56006   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56007   {
56008     try {
56009       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56010     } catch (std::out_of_range& e) {
56011       {
56012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56013       };
56014     } catch (std::exception& e) {
56015       {
56016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56017       };
56018     } catch (Dali::DaliException e) {
56019       {
56020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56021       };
56022     } catch (...) {
56023       {
56024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56025       };
56026     }
56027   }
56028
56029   jresult = result;
56030   return jresult;
56031 }
56032
56033
56034 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56035   unsigned long jresult ;
56036   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56037   std::size_t result;
56038
56039   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56040   {
56041     try {
56042       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56043     } catch (std::out_of_range& e) {
56044       {
56045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56046       };
56047     } catch (std::exception& e) {
56048       {
56049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56050       };
56051     } catch (Dali::DaliException e) {
56052       {
56053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56054       };
56055     } catch (...) {
56056       {
56057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56058       };
56059     }
56060   }
56061
56062   jresult = (unsigned long)result;
56063   return jresult;
56064 }
56065
56066
56067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56068   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56069   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56070
56071   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56072   arg2 = (void (*)(Dali::Actor))jarg2;
56073   {
56074     try {
56075       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56076     } catch (std::out_of_range& e) {
56077       {
56078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56079       };
56080     } catch (std::exception& e) {
56081       {
56082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56083       };
56084     } catch (Dali::DaliException e) {
56085       {
56086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56087       };
56088     } catch (...) {
56089       {
56090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56091       };
56092     }
56093   }
56094
56095 }
56096
56097
56098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56099   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56100   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56101
56102   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56103   arg2 = (void (*)(Dali::Actor))jarg2;
56104   {
56105     try {
56106       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56107     } catch (std::out_of_range& e) {
56108       {
56109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56110       };
56111     } catch (std::exception& e) {
56112       {
56113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56114       };
56115     } catch (Dali::DaliException e) {
56116       {
56117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56118       };
56119     } catch (...) {
56120       {
56121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56122       };
56123     }
56124   }
56125
56126 }
56127
56128
56129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56130   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56131   Dali::Actor arg2 ;
56132   Dali::Actor *argp2 ;
56133
56134   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56135   argp2 = (Dali::Actor *)jarg2;
56136   if (!argp2) {
56137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56138     return ;
56139   }
56140   arg2 = *argp2;
56141   {
56142     try {
56143       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56144     } catch (std::out_of_range& e) {
56145       {
56146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56147       };
56148     } catch (std::exception& e) {
56149       {
56150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56151       };
56152     } catch (Dali::DaliException e) {
56153       {
56154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56155       };
56156     } catch (...) {
56157       {
56158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56159       };
56160     }
56161   }
56162
56163 }
56164
56165
56166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56167   void * jresult ;
56168   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56169
56170   {
56171     try {
56172       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56173     } catch (std::out_of_range& e) {
56174       {
56175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56176       };
56177     } catch (std::exception& e) {
56178       {
56179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56180       };
56181     } catch (Dali::DaliException e) {
56182       {
56183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56184       };
56185     } catch (...) {
56186       {
56187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56188       };
56189     }
56190   }
56191
56192   jresult = (void *)result;
56193   return jresult;
56194 }
56195
56196
56197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56198   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56199
56200   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56201   {
56202     try {
56203       delete arg1;
56204     } catch (std::out_of_range& e) {
56205       {
56206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56207       };
56208     } catch (std::exception& e) {
56209       {
56210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56211       };
56212     } catch (Dali::DaliException e) {
56213       {
56214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56215       };
56216     } catch (...) {
56217       {
56218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56219       };
56220     }
56221   }
56222
56223 }
56224
56225
56226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56227   unsigned int jresult ;
56228   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56229   bool result;
56230
56231   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56232   {
56233     try {
56234       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56235     } catch (std::out_of_range& e) {
56236       {
56237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56238       };
56239     } catch (std::exception& e) {
56240       {
56241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56242       };
56243     } catch (Dali::DaliException e) {
56244       {
56245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56246       };
56247     } catch (...) {
56248       {
56249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56250       };
56251     }
56252   }
56253
56254   jresult = result;
56255   return jresult;
56256 }
56257
56258
56259 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56260   unsigned long jresult ;
56261   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56262   std::size_t result;
56263
56264   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56265   {
56266     try {
56267       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56268     } catch (std::out_of_range& e) {
56269       {
56270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56271       };
56272     } catch (std::exception& e) {
56273       {
56274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56275       };
56276     } catch (Dali::DaliException e) {
56277       {
56278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56279       };
56280     } catch (...) {
56281       {
56282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56283       };
56284     }
56285   }
56286
56287   jresult = (unsigned long)result;
56288   return jresult;
56289 }
56290
56291
56292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56293   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56294   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56295
56296   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56297   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56298   {
56299     try {
56300       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56301     } catch (std::out_of_range& e) {
56302       {
56303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56304       };
56305     } catch (std::exception& e) {
56306       {
56307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56308       };
56309     } catch (Dali::DaliException e) {
56310       {
56311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56312       };
56313     } catch (...) {
56314       {
56315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56316       };
56317     }
56318   }
56319
56320 }
56321
56322
56323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56324   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56325   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56326
56327   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56328   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56329   {
56330     try {
56331       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56332     } catch (std::out_of_range& e) {
56333       {
56334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56335       };
56336     } catch (std::exception& e) {
56337       {
56338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56339       };
56340     } catch (Dali::DaliException e) {
56341       {
56342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56343       };
56344     } catch (...) {
56345       {
56346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56347       };
56348     }
56349   }
56350
56351 }
56352
56353
56354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56355   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56356   Dali::KeyEvent *arg2 = 0 ;
56357
56358   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56359   arg2 = (Dali::KeyEvent *)jarg2;
56360   if (!arg2) {
56361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56362     return ;
56363   }
56364   {
56365     try {
56366       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56367     } catch (std::out_of_range& e) {
56368       {
56369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56370       };
56371     } catch (std::exception& e) {
56372       {
56373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56374       };
56375     } catch (Dali::DaliException e) {
56376       {
56377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56378       };
56379     } catch (...) {
56380       {
56381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56382       };
56383     }
56384   }
56385
56386 }
56387
56388
56389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56390   void * jresult ;
56391   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56392
56393   {
56394     try {
56395       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56396     } catch (std::out_of_range& e) {
56397       {
56398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56399       };
56400     } catch (std::exception& e) {
56401       {
56402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56403       };
56404     } catch (Dali::DaliException e) {
56405       {
56406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56407       };
56408     } catch (...) {
56409       {
56410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56411       };
56412     }
56413   }
56414
56415   jresult = (void *)result;
56416   return jresult;
56417 }
56418
56419
56420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56421   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56422
56423   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56424   {
56425     try {
56426       delete arg1;
56427     } catch (std::out_of_range& e) {
56428       {
56429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56430       };
56431     } catch (std::exception& e) {
56432       {
56433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56434       };
56435     } catch (Dali::DaliException e) {
56436       {
56437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56438       };
56439     } catch (...) {
56440       {
56441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56442       };
56443     }
56444   }
56445
56446 }
56447
56448
56449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56450   unsigned int jresult ;
56451   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56452   bool result;
56453
56454   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56455   {
56456     try {
56457       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56458     } catch (std::out_of_range& e) {
56459       {
56460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56461       };
56462     } catch (std::exception& e) {
56463       {
56464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56465       };
56466     } catch (Dali::DaliException e) {
56467       {
56468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56469       };
56470     } catch (...) {
56471       {
56472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56473       };
56474     }
56475   }
56476
56477   jresult = result;
56478   return jresult;
56479 }
56480
56481
56482 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56483   unsigned long jresult ;
56484   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56485   std::size_t result;
56486
56487   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56488   {
56489     try {
56490       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56491     } catch (std::out_of_range& e) {
56492       {
56493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56494       };
56495     } catch (std::exception& e) {
56496       {
56497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56498       };
56499     } catch (Dali::DaliException e) {
56500       {
56501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56502       };
56503     } catch (...) {
56504       {
56505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56506       };
56507     }
56508   }
56509
56510   jresult = (unsigned long)result;
56511   return jresult;
56512 }
56513
56514
56515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56516   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56517   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56518
56519   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56520   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56521   {
56522     try {
56523       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56524     } catch (std::out_of_range& e) {
56525       {
56526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56527       };
56528     } catch (std::exception& e) {
56529       {
56530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56531       };
56532     } catch (Dali::DaliException e) {
56533       {
56534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56535       };
56536     } catch (...) {
56537       {
56538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56539       };
56540     }
56541   }
56542
56543 }
56544
56545
56546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56547   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56548   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56549
56550   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56551   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56552   {
56553     try {
56554       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56555     } catch (std::out_of_range& e) {
56556       {
56557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56558       };
56559     } catch (std::exception& e) {
56560       {
56561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56562       };
56563     } catch (Dali::DaliException e) {
56564       {
56565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56566       };
56567     } catch (...) {
56568       {
56569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56570       };
56571     }
56572   }
56573
56574 }
56575
56576
56577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56578   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56579   Dali::TouchData *arg2 = 0 ;
56580
56581   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56582   arg2 = (Dali::TouchData *)jarg2;
56583   if (!arg2) {
56584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56585     return ;
56586   }
56587   {
56588     try {
56589       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56590     } catch (std::out_of_range& e) {
56591       {
56592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56593       };
56594     } catch (std::exception& e) {
56595       {
56596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56597       };
56598     } catch (Dali::DaliException e) {
56599       {
56600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56601       };
56602     } catch (...) {
56603       {
56604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56605       };
56606     }
56607   }
56608
56609 }
56610
56611
56612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56613   void * jresult ;
56614   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56615
56616   {
56617     try {
56618       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56619     } catch (std::out_of_range& e) {
56620       {
56621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56622       };
56623     } catch (std::exception& e) {
56624       {
56625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56626       };
56627     } catch (Dali::DaliException e) {
56628       {
56629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56630       };
56631     } catch (...) {
56632       {
56633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56634       };
56635     }
56636   }
56637
56638   jresult = (void *)result;
56639   return jresult;
56640 }
56641
56642
56643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56644   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56645
56646   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56647   {
56648     try {
56649       delete arg1;
56650     } catch (std::out_of_range& e) {
56651       {
56652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56653       };
56654     } catch (std::exception& e) {
56655       {
56656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56657       };
56658     } catch (Dali::DaliException e) {
56659       {
56660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56661       };
56662     } catch (...) {
56663       {
56664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56665       };
56666     }
56667   }
56668
56669 }
56670
56671
56672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56673   unsigned int jresult ;
56674   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56675   bool result;
56676
56677   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56678   {
56679     try {
56680       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56681     } catch (std::out_of_range& e) {
56682       {
56683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56684       };
56685     } catch (std::exception& e) {
56686       {
56687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56688       };
56689     } catch (Dali::DaliException e) {
56690       {
56691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56692       };
56693     } catch (...) {
56694       {
56695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56696       };
56697     }
56698   }
56699
56700   jresult = result;
56701   return jresult;
56702 }
56703
56704
56705 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56706   unsigned long jresult ;
56707   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56708   std::size_t result;
56709
56710   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56711   {
56712     try {
56713       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56714     } catch (std::out_of_range& e) {
56715       {
56716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56717       };
56718     } catch (std::exception& e) {
56719       {
56720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56721       };
56722     } catch (Dali::DaliException e) {
56723       {
56724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56725       };
56726     } catch (...) {
56727       {
56728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56729       };
56730     }
56731   }
56732
56733   jresult = (unsigned long)result;
56734   return jresult;
56735 }
56736
56737
56738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56739   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56740   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56741
56742   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56743   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56744   {
56745     try {
56746       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56747     } catch (std::out_of_range& e) {
56748       {
56749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56750       };
56751     } catch (std::exception& e) {
56752       {
56753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56754       };
56755     } catch (Dali::DaliException e) {
56756       {
56757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56758       };
56759     } catch (...) {
56760       {
56761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56762       };
56763     }
56764   }
56765
56766 }
56767
56768
56769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56770   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56771   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56772
56773   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56774   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56775   {
56776     try {
56777       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56778     } catch (std::out_of_range& e) {
56779       {
56780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56781       };
56782     } catch (std::exception& e) {
56783       {
56784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56785       };
56786     } catch (Dali::DaliException e) {
56787       {
56788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56789       };
56790     } catch (...) {
56791       {
56792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56793       };
56794     }
56795   }
56796
56797 }
56798
56799
56800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56801   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56802   Dali::WheelEvent *arg2 = 0 ;
56803
56804   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56805   arg2 = (Dali::WheelEvent *)jarg2;
56806   if (!arg2) {
56807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56808     return ;
56809   }
56810   {
56811     try {
56812       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56813     } catch (std::out_of_range& e) {
56814       {
56815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56816       };
56817     } catch (std::exception& e) {
56818       {
56819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56820       };
56821     } catch (Dali::DaliException e) {
56822       {
56823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56824       };
56825     } catch (...) {
56826       {
56827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56828       };
56829     }
56830   }
56831
56832 }
56833
56834
56835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56836   void * jresult ;
56837   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56838
56839   {
56840     try {
56841       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56842     } catch (std::out_of_range& e) {
56843       {
56844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56845       };
56846     } catch (std::exception& e) {
56847       {
56848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56849       };
56850     } catch (Dali::DaliException e) {
56851       {
56852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56853       };
56854     } catch (...) {
56855       {
56856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56857       };
56858     }
56859   }
56860
56861   jresult = (void *)result;
56862   return jresult;
56863 }
56864
56865
56866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56867   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56868
56869   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56870   {
56871     try {
56872       delete arg1;
56873     } catch (std::out_of_range& e) {
56874       {
56875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56876       };
56877     } catch (std::exception& e) {
56878       {
56879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56880       };
56881     } catch (Dali::DaliException e) {
56882       {
56883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56884       };
56885     } catch (...) {
56886       {
56887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56888       };
56889     }
56890   }
56891
56892 }
56893
56894
56895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56896   void * jresult ;
56897   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56898
56899   {
56900     try {
56901       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56902     } catch (std::out_of_range& e) {
56903       {
56904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56905       };
56906     } catch (std::exception& e) {
56907       {
56908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56909       };
56910     } catch (Dali::DaliException e) {
56911       {
56912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56913       };
56914     } catch (...) {
56915       {
56916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56917       };
56918     }
56919   }
56920
56921   jresult = (void *)result;
56922   return jresult;
56923 }
56924
56925
56926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56927   void * jresult ;
56928   Dali::Radian arg1 ;
56929   Dali::Radian arg2 ;
56930   Dali::Radian *argp1 ;
56931   Dali::Radian *argp2 ;
56932   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56933
56934   argp1 = (Dali::Radian *)jarg1;
56935   if (!argp1) {
56936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56937     return 0;
56938   }
56939   arg1 = *argp1;
56940   argp2 = (Dali::Radian *)jarg2;
56941   if (!argp2) {
56942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56943     return 0;
56944   }
56945   arg2 = *argp2;
56946   {
56947     try {
56948       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56949     } catch (std::out_of_range& e) {
56950       {
56951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56952       };
56953     } catch (std::exception& e) {
56954       {
56955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56956       };
56957     } catch (Dali::DaliException e) {
56958       {
56959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56960       };
56961     } catch (...) {
56962       {
56963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56964       };
56965     }
56966   }
56967
56968   jresult = (void *)result;
56969   return jresult;
56970 }
56971
56972
56973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56974   void * jresult ;
56975   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56976   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56977
56978   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56979   if (!arg1) {
56980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56981     return 0;
56982   }
56983   {
56984     try {
56985       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56986     } catch (std::out_of_range& e) {
56987       {
56988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56989       };
56990     } catch (std::exception& e) {
56991       {
56992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56993       };
56994     } catch (Dali::DaliException e) {
56995       {
56996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56997       };
56998     } catch (...) {
56999       {
57000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57001       };
57002     }
57003   }
57004
57005   jresult = (void *)result;
57006   return jresult;
57007 }
57008
57009
57010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57011   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57012   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57013
57014   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57015   arg2 = (Dali::Radian *)jarg2;
57016   if (arg1) (arg1)->first = *arg2;
57017 }
57018
57019
57020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57021   void * jresult ;
57022   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57023   Dali::Radian *result = 0 ;
57024
57025   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57026   result = (Dali::Radian *)& ((arg1)->first);
57027   jresult = (void *)result;
57028   return jresult;
57029 }
57030
57031
57032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57033   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57034   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57035
57036   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57037   arg2 = (Dali::Radian *)jarg2;
57038   if (arg1) (arg1)->second = *arg2;
57039 }
57040
57041
57042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57043   void * jresult ;
57044   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57045   Dali::Radian *result = 0 ;
57046
57047   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57048   result = (Dali::Radian *)& ((arg1)->second);
57049   jresult = (void *)result;
57050   return jresult;
57051 }
57052
57053
57054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57055   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57056
57057   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57058   {
57059     try {
57060       delete arg1;
57061     } catch (std::out_of_range& e) {
57062       {
57063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57064       };
57065     } catch (std::exception& e) {
57066       {
57067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57068       };
57069     } catch (Dali::DaliException e) {
57070       {
57071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57072       };
57073     } catch (...) {
57074       {
57075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57076       };
57077     }
57078   }
57079
57080 }
57081
57082
57083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57084   unsigned int jresult ;
57085   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57086   bool result;
57087
57088   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57089   {
57090     try {
57091       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);
57092     } catch (std::out_of_range& e) {
57093       {
57094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57095       };
57096     } catch (std::exception& e) {
57097       {
57098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57099       };
57100     } catch (Dali::DaliException e) {
57101       {
57102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57103       };
57104     } catch (...) {
57105       {
57106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57107       };
57108     }
57109   }
57110
57111   jresult = result;
57112   return jresult;
57113 }
57114
57115
57116 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57117   unsigned long jresult ;
57118   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57119   std::size_t result;
57120
57121   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57122   {
57123     try {
57124       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);
57125     } catch (std::out_of_range& e) {
57126       {
57127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57128       };
57129     } catch (std::exception& e) {
57130       {
57131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57132       };
57133     } catch (Dali::DaliException e) {
57134       {
57135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57136       };
57137     } catch (...) {
57138       {
57139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57140       };
57141     }
57142   }
57143
57144   jresult = (unsigned long)result;
57145   return jresult;
57146 }
57147
57148
57149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57150   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57151   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57152
57153   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57154   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57155   {
57156     try {
57157       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57158     } catch (std::out_of_range& e) {
57159       {
57160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57161       };
57162     } catch (std::exception& e) {
57163       {
57164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57165       };
57166     } catch (Dali::DaliException e) {
57167       {
57168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57169       };
57170     } catch (...) {
57171       {
57172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57173       };
57174     }
57175   }
57176
57177 }
57178
57179
57180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57181   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57182   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57183
57184   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57185   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57186   {
57187     try {
57188       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57189     } catch (std::out_of_range& e) {
57190       {
57191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57192       };
57193     } catch (std::exception& e) {
57194       {
57195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57196       };
57197     } catch (Dali::DaliException e) {
57198       {
57199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57200       };
57201     } catch (...) {
57202       {
57203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57204       };
57205     }
57206   }
57207
57208 }
57209
57210
57211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57212   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57213   Dali::Actor arg2 ;
57214   Dali::PanGesture *arg3 = 0 ;
57215   Dali::Actor *argp2 ;
57216
57217   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57218   argp2 = (Dali::Actor *)jarg2;
57219   if (!argp2) {
57220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57221     return ;
57222   }
57223   arg2 = *argp2;
57224   arg3 = (Dali::PanGesture *)jarg3;
57225   if (!arg3) {
57226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57227     return ;
57228   }
57229   {
57230     try {
57231       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57232     } catch (std::out_of_range& e) {
57233       {
57234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57235       };
57236     } catch (std::exception& e) {
57237       {
57238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57239       };
57240     } catch (Dali::DaliException e) {
57241       {
57242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57243       };
57244     } catch (...) {
57245       {
57246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57247       };
57248     }
57249   }
57250
57251 }
57252
57253
57254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57255   void * jresult ;
57256   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57257
57258   {
57259     try {
57260       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57261     } catch (std::out_of_range& e) {
57262       {
57263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57264       };
57265     } catch (std::exception& e) {
57266       {
57267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57268       };
57269     } catch (Dali::DaliException e) {
57270       {
57271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57272       };
57273     } catch (...) {
57274       {
57275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57276       };
57277     }
57278   }
57279
57280   jresult = (void *)result;
57281   return jresult;
57282 }
57283
57284
57285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57286   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57287
57288   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57289   {
57290     try {
57291       delete arg1;
57292     } catch (std::out_of_range& e) {
57293       {
57294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57295       };
57296     } catch (std::exception& e) {
57297       {
57298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57299       };
57300     } catch (Dali::DaliException e) {
57301       {
57302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57303       };
57304     } catch (...) {
57305       {
57306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57307       };
57308     }
57309   }
57310
57311 }
57312
57313
57314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57315   unsigned int jresult ;
57316   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57317   bool result;
57318
57319   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57320   {
57321     try {
57322       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);
57323     } catch (std::out_of_range& e) {
57324       {
57325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57326       };
57327     } catch (std::exception& e) {
57328       {
57329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57330       };
57331     } catch (Dali::DaliException e) {
57332       {
57333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57334       };
57335     } catch (...) {
57336       {
57337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57338       };
57339     }
57340   }
57341
57342   jresult = result;
57343   return jresult;
57344 }
57345
57346
57347 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57348   unsigned long jresult ;
57349   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57350   std::size_t result;
57351
57352   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57353   {
57354     try {
57355       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);
57356     } catch (std::out_of_range& e) {
57357       {
57358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57359       };
57360     } catch (std::exception& e) {
57361       {
57362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57363       };
57364     } catch (Dali::DaliException e) {
57365       {
57366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57367       };
57368     } catch (...) {
57369       {
57370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57371       };
57372     }
57373   }
57374
57375   jresult = (unsigned long)result;
57376   return jresult;
57377 }
57378
57379
57380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57381   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57382   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57383
57384   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57385   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57386   {
57387     try {
57388       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57389     } catch (std::out_of_range& e) {
57390       {
57391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57392       };
57393     } catch (std::exception& e) {
57394       {
57395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57396       };
57397     } catch (Dali::DaliException e) {
57398       {
57399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57400       };
57401     } catch (...) {
57402       {
57403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57404       };
57405     }
57406   }
57407
57408 }
57409
57410
57411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57412   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57413   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57414
57415   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57416   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57417   {
57418     try {
57419       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57420     } catch (std::out_of_range& e) {
57421       {
57422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57423       };
57424     } catch (std::exception& e) {
57425       {
57426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57427       };
57428     } catch (Dali::DaliException e) {
57429       {
57430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57431       };
57432     } catch (...) {
57433       {
57434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57435       };
57436     }
57437   }
57438
57439 }
57440
57441
57442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57443   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57444   Dali::Actor arg2 ;
57445   Dali::PinchGesture *arg3 = 0 ;
57446   Dali::Actor *argp2 ;
57447
57448   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57449   argp2 = (Dali::Actor *)jarg2;
57450   if (!argp2) {
57451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57452     return ;
57453   }
57454   arg2 = *argp2;
57455   arg3 = (Dali::PinchGesture *)jarg3;
57456   if (!arg3) {
57457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57458     return ;
57459   }
57460   {
57461     try {
57462       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57463     } catch (std::out_of_range& e) {
57464       {
57465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57466       };
57467     } catch (std::exception& e) {
57468       {
57469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57470       };
57471     } catch (Dali::DaliException e) {
57472       {
57473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57474       };
57475     } catch (...) {
57476       {
57477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57478       };
57479     }
57480   }
57481
57482 }
57483
57484
57485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57486   void * jresult ;
57487   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57488
57489   {
57490     try {
57491       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57492     } catch (std::out_of_range& e) {
57493       {
57494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57495       };
57496     } catch (std::exception& e) {
57497       {
57498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57499       };
57500     } catch (Dali::DaliException e) {
57501       {
57502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57503       };
57504     } catch (...) {
57505       {
57506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57507       };
57508     }
57509   }
57510
57511   jresult = (void *)result;
57512   return jresult;
57513 }
57514
57515
57516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57517   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57518
57519   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57520   {
57521     try {
57522       delete arg1;
57523     } catch (std::out_of_range& e) {
57524       {
57525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57526       };
57527     } catch (std::exception& e) {
57528       {
57529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57530       };
57531     } catch (Dali::DaliException e) {
57532       {
57533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57534       };
57535     } catch (...) {
57536       {
57537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57538       };
57539     }
57540   }
57541
57542 }
57543
57544
57545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57546   unsigned int jresult ;
57547   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57548   bool result;
57549
57550   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57551   {
57552     try {
57553       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);
57554     } catch (std::out_of_range& e) {
57555       {
57556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57557       };
57558     } catch (std::exception& e) {
57559       {
57560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57561       };
57562     } catch (Dali::DaliException e) {
57563       {
57564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57565       };
57566     } catch (...) {
57567       {
57568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57569       };
57570     }
57571   }
57572
57573   jresult = result;
57574   return jresult;
57575 }
57576
57577
57578 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57579   unsigned long jresult ;
57580   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57581   std::size_t result;
57582
57583   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57584   {
57585     try {
57586       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);
57587     } catch (std::out_of_range& e) {
57588       {
57589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57590       };
57591     } catch (std::exception& e) {
57592       {
57593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57594       };
57595     } catch (Dali::DaliException e) {
57596       {
57597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57598       };
57599     } catch (...) {
57600       {
57601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57602       };
57603     }
57604   }
57605
57606   jresult = (unsigned long)result;
57607   return jresult;
57608 }
57609
57610
57611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57612   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57613   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57614
57615   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57616   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57617   {
57618     try {
57619       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57620     } catch (std::out_of_range& e) {
57621       {
57622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57623       };
57624     } catch (std::exception& e) {
57625       {
57626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57627       };
57628     } catch (Dali::DaliException e) {
57629       {
57630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57631       };
57632     } catch (...) {
57633       {
57634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57635       };
57636     }
57637   }
57638
57639 }
57640
57641
57642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57643   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57644   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57645
57646   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57647   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57648   {
57649     try {
57650       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57651     } catch (std::out_of_range& e) {
57652       {
57653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57654       };
57655     } catch (std::exception& e) {
57656       {
57657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57658       };
57659     } catch (Dali::DaliException e) {
57660       {
57661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57662       };
57663     } catch (...) {
57664       {
57665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57666       };
57667     }
57668   }
57669
57670 }
57671
57672
57673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57674   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57675   Dali::Actor arg2 ;
57676   Dali::TapGesture *arg3 = 0 ;
57677   Dali::Actor *argp2 ;
57678
57679   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57680   argp2 = (Dali::Actor *)jarg2;
57681   if (!argp2) {
57682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57683     return ;
57684   }
57685   arg2 = *argp2;
57686   arg3 = (Dali::TapGesture *)jarg3;
57687   if (!arg3) {
57688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57689     return ;
57690   }
57691   {
57692     try {
57693       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57694     } catch (std::out_of_range& e) {
57695       {
57696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57697       };
57698     } catch (std::exception& e) {
57699       {
57700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57701       };
57702     } catch (Dali::DaliException e) {
57703       {
57704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57705       };
57706     } catch (...) {
57707       {
57708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57709       };
57710     }
57711   }
57712
57713 }
57714
57715
57716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57717   void * jresult ;
57718   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57719
57720   {
57721     try {
57722       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57723     } catch (std::out_of_range& e) {
57724       {
57725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57726       };
57727     } catch (std::exception& e) {
57728       {
57729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57730       };
57731     } catch (Dali::DaliException e) {
57732       {
57733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57734       };
57735     } catch (...) {
57736       {
57737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57738       };
57739     }
57740   }
57741
57742   jresult = (void *)result;
57743   return jresult;
57744 }
57745
57746
57747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57748   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57749
57750   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57751   {
57752     try {
57753       delete arg1;
57754     } catch (std::out_of_range& e) {
57755       {
57756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57757       };
57758     } catch (std::exception& e) {
57759       {
57760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57761       };
57762     } catch (Dali::DaliException e) {
57763       {
57764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57765       };
57766     } catch (...) {
57767       {
57768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57769       };
57770     }
57771   }
57772
57773 }
57774
57775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57776   unsigned int jresult ;
57777   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57778   bool result;
57779
57780   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57781   {
57782     try {
57783       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57784     } catch (std::out_of_range& e) {
57785       {
57786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57787       };
57788     } catch (std::exception& e) {
57789       {
57790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57791       };
57792     } catch (Dali::DaliException e) {
57793       {
57794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57795       };
57796     } catch (...) {
57797       {
57798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57799       };
57800     }
57801   }
57802
57803   jresult = result;
57804   return jresult;
57805 }
57806
57807
57808 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57809   unsigned long jresult ;
57810   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57811   std::size_t result;
57812
57813   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57814   {
57815     try {
57816       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57817     } catch (std::out_of_range& e) {
57818       {
57819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57820       };
57821     } catch (std::exception& e) {
57822       {
57823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57824       };
57825     } catch (Dali::DaliException e) {
57826       {
57827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57828       };
57829     } catch (...) {
57830       {
57831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57832       };
57833     }
57834   }
57835
57836   jresult = (unsigned long)result;
57837   return jresult;
57838 }
57839
57840
57841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57842   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57843   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57844
57845   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57846   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57847   {
57848     try {
57849       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57850     } catch (std::out_of_range& e) {
57851       {
57852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57853       };
57854     } catch (std::exception& e) {
57855       {
57856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57857       };
57858     } catch (Dali::DaliException e) {
57859       {
57860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57861       };
57862     } catch (...) {
57863       {
57864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57865       };
57866     }
57867   }
57868
57869 }
57870
57871
57872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57873   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57874   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57875
57876   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57877   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57878   {
57879     try {
57880       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57881     } catch (std::out_of_range& e) {
57882       {
57883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57884       };
57885     } catch (std::exception& e) {
57886       {
57887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57888       };
57889     } catch (Dali::DaliException e) {
57890       {
57891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57892       };
57893     } catch (...) {
57894       {
57895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57896       };
57897     }
57898   }
57899
57900 }
57901
57902
57903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57904   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57905   Dali::ResourceImage arg2 ;
57906   Dali::ResourceImage *argp2 ;
57907
57908   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57909   argp2 = (Dali::ResourceImage *)jarg2;
57910   if (!argp2) {
57911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57912     return ;
57913   }
57914   arg2 = *argp2;
57915   {
57916     try {
57917       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57918     } catch (std::out_of_range& e) {
57919       {
57920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57921       };
57922     } catch (std::exception& e) {
57923       {
57924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57925       };
57926     } catch (Dali::DaliException e) {
57927       {
57928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57929       };
57930     } catch (...) {
57931       {
57932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57933       };
57934     }
57935   }
57936
57937 }
57938
57939
57940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57941   void * jresult ;
57942   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57943
57944   {
57945     try {
57946       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57947     } catch (std::out_of_range& e) {
57948       {
57949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57950       };
57951     } catch (std::exception& e) {
57952       {
57953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57954       };
57955     } catch (Dali::DaliException e) {
57956       {
57957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57958       };
57959     } catch (...) {
57960       {
57961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57962       };
57963     }
57964   }
57965
57966   jresult = (void *)result;
57967   return jresult;
57968 }
57969
57970
57971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57972   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57973
57974   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57975   {
57976     try {
57977       delete arg1;
57978     } catch (std::out_of_range& e) {
57979       {
57980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57981       };
57982     } catch (std::exception& e) {
57983       {
57984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57985       };
57986     } catch (Dali::DaliException e) {
57987       {
57988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57989       };
57990     } catch (...) {
57991       {
57992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57993       };
57994     }
57995   }
57996
57997 }
57998
57999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58000   unsigned int jresult ;
58001   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58002   bool result = false;
58003
58004   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58005   {
58006     try {
58007       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);
58008     } catch (std::out_of_range& e) {
58009       {
58010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58011       };
58012     } catch (std::exception& e) {
58013       {
58014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58015       };
58016     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58017   }
58018   jresult = result;
58019   return jresult;
58020 }
58021
58022 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58023   unsigned long jresult ;
58024   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58025   std::size_t result = 0;
58026
58027   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58028   {
58029     try {
58030       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);
58031     } catch (std::out_of_range& e) {
58032       {
58033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58034       };
58035     } catch (std::exception& e) {
58036       {
58037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58038       };
58039     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58040   }
58041   jresult = (unsigned long)result;
58042   return jresult;
58043 }
58044
58045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58046   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58047   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58048
58049   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58050   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58051   {
58052     try {
58053       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58054     } catch (std::out_of_range& e) {
58055       {
58056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58057       };
58058     } catch (std::exception& e) {
58059       {
58060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58061       };
58062     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58063   }
58064 }
58065
58066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58067   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58068   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58069
58070   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58071   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58072   {
58073     try {
58074       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58075     } catch (std::out_of_range& e) {
58076       {
58077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58078       };
58079     } catch (std::exception& e) {
58080       {
58081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58082       };
58083     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58084   }
58085 }
58086
58087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58088   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58089   Dali::Actor arg2 ;
58090   //bool arg3 ;
58091   Dali::LayoutDirection::Type arg4 ;
58092   Dali::Actor *argp2 ;
58093
58094   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58095   argp2 = (Dali::Actor *)jarg2;
58096   if (!argp2) {
58097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58098     return ;
58099   }
58100   arg2 = *argp2;
58101   //arg3 = jarg3 ? true : false;
58102   arg4 = (Dali::LayoutDirection::Type)jarg4;
58103   {
58104     try {
58105       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58106     } catch (std::out_of_range& e) {
58107       {
58108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58109       };
58110     } catch (std::exception& e) {
58111       {
58112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58113       };
58114     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58115   }
58116 }
58117
58118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58119   void * jresult ;
58120   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58121
58122   {
58123     try {
58124       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58125     } catch (std::out_of_range& e) {
58126       {
58127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58128       };
58129     } catch (std::exception& e) {
58130       {
58131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58132       };
58133     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58134   }
58135   jresult = (void *)result;
58136   return jresult;
58137 }
58138
58139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58140   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58141
58142   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58143   {
58144     try {
58145       delete arg1;
58146     } catch (std::out_of_range& e) {
58147       {
58148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58149       };
58150     } catch (std::exception& e) {
58151       {
58152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58153       };
58154     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58155   }
58156 }
58157
58158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58159   unsigned int jresult ;
58160   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58161   bool result;
58162
58163   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58164   {
58165     try {
58166       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);
58167     } catch (std::out_of_range& e) {
58168       {
58169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58170       };
58171     } catch (std::exception& e) {
58172       {
58173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58174       };
58175     } catch (Dali::DaliException e) {
58176       {
58177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58178       };
58179     } catch (...) {
58180       {
58181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58182       };
58183     }
58184   }
58185
58186   jresult = result;
58187   return jresult;
58188 }
58189
58190
58191 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58192   unsigned long jresult ;
58193   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58194   std::size_t result;
58195
58196   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58197   {
58198     try {
58199       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);
58200     } catch (std::out_of_range& e) {
58201       {
58202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58203       };
58204     } catch (std::exception& e) {
58205       {
58206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58207       };
58208     } catch (Dali::DaliException e) {
58209       {
58210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58211       };
58212     } catch (...) {
58213       {
58214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58215       };
58216     }
58217   }
58218
58219   jresult = (unsigned long)result;
58220   return jresult;
58221 }
58222
58223
58224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58225   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58226   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58227
58228   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58229   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58230   {
58231     try {
58232       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58233     } catch (std::out_of_range& e) {
58234       {
58235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58236       };
58237     } catch (std::exception& e) {
58238       {
58239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58240       };
58241     } catch (Dali::DaliException e) {
58242       {
58243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58244       };
58245     } catch (...) {
58246       {
58247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58248       };
58249     }
58250   }
58251
58252 }
58253
58254
58255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58256   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58257   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58258
58259   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58260   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58261   {
58262     try {
58263       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58264     } catch (std::out_of_range& e) {
58265       {
58266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58267       };
58268     } catch (std::exception& e) {
58269       {
58270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58271       };
58272     } catch (Dali::DaliException e) {
58273       {
58274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58275       };
58276     } catch (...) {
58277       {
58278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58279       };
58280     }
58281   }
58282
58283 }
58284
58285
58286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58287   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58288   Dali::Actor arg2 ;
58289   bool arg3 ;
58290   Dali::DevelActor::VisibilityChange::Type arg4 ;
58291   Dali::Actor *argp2 ;
58292
58293   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58294   argp2 = (Dali::Actor *)jarg2;
58295   if (!argp2) {
58296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58297     return ;
58298   }
58299   arg2 = *argp2;
58300   arg3 = jarg3 ? true : false;
58301   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58302   {
58303     try {
58304       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58305     } catch (std::out_of_range& e) {
58306       {
58307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58308       };
58309     } catch (std::exception& e) {
58310       {
58311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58312       };
58313     } catch (Dali::DaliException e) {
58314       {
58315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58316       };
58317     } catch (...) {
58318       {
58319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58320       };
58321     }
58322   }
58323
58324 }
58325
58326
58327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58328   void * jresult ;
58329   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58330
58331   {
58332     try {
58333       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58334     } catch (std::out_of_range& e) {
58335       {
58336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58337       };
58338     } catch (std::exception& e) {
58339       {
58340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58341       };
58342     } catch (Dali::DaliException e) {
58343       {
58344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58345       };
58346     } catch (...) {
58347       {
58348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58349       };
58350     }
58351   }
58352
58353   jresult = (void *)result;
58354   return jresult;
58355 }
58356
58357
58358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58359   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58360
58361   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58362   {
58363     try {
58364       delete arg1;
58365     } catch (std::out_of_range& e) {
58366       {
58367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58368       };
58369     } catch (std::exception& e) {
58370       {
58371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58372       };
58373     } catch (Dali::DaliException e) {
58374       {
58375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58376       };
58377     } catch (...) {
58378       {
58379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58380       };
58381     }
58382   }
58383
58384 }
58385
58386
58387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58388   void * jresult ;
58389   Dali::Timer *result = 0 ;
58390
58391   {
58392     try {
58393       result = (Dali::Timer *)new Dali::Timer();
58394     } catch (std::out_of_range& e) {
58395       {
58396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58397       };
58398     } catch (std::exception& e) {
58399       {
58400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58401       };
58402     } catch (Dali::DaliException e) {
58403       {
58404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58405       };
58406     } catch (...) {
58407       {
58408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58409       };
58410     }
58411   }
58412
58413   jresult = (void *)result;
58414   return jresult;
58415 }
58416
58417
58418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58419   void * jresult ;
58420   unsigned int arg1 ;
58421   Dali::Timer result;
58422
58423   arg1 = (unsigned int)jarg1;
58424   {
58425     try {
58426       result = Dali::Timer::New(arg1);
58427     } catch (std::out_of_range& e) {
58428       {
58429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58430       };
58431     } catch (std::exception& e) {
58432       {
58433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58434       };
58435     } catch (Dali::DaliException e) {
58436       {
58437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58438       };
58439     } catch (...) {
58440       {
58441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58442       };
58443     }
58444   }
58445
58446   jresult = new Dali::Timer((const Dali::Timer &)result);
58447   return jresult;
58448 }
58449
58450
58451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58452   void * jresult ;
58453   Dali::Timer *arg1 = 0 ;
58454   Dali::Timer *result = 0 ;
58455
58456   arg1 = (Dali::Timer *)jarg1;
58457   if (!arg1) {
58458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58459     return 0;
58460   }
58461   {
58462     try {
58463       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58464     } catch (std::out_of_range& e) {
58465       {
58466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58467       };
58468     } catch (std::exception& e) {
58469       {
58470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58471       };
58472     } catch (Dali::DaliException e) {
58473       {
58474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58475       };
58476     } catch (...) {
58477       {
58478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58479       };
58480     }
58481   }
58482
58483   jresult = (void *)result;
58484   return jresult;
58485 }
58486
58487
58488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58489   void * jresult ;
58490   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58491   Dali::Timer *arg2 = 0 ;
58492   Dali::Timer *result = 0 ;
58493
58494   arg1 = (Dali::Timer *)jarg1;
58495   arg2 = (Dali::Timer *)jarg2;
58496   if (!arg2) {
58497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58498     return 0;
58499   }
58500   {
58501     try {
58502       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58503     } catch (std::out_of_range& e) {
58504       {
58505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58506       };
58507     } catch (std::exception& e) {
58508       {
58509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58510       };
58511     } catch (Dali::DaliException e) {
58512       {
58513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58514       };
58515     } catch (...) {
58516       {
58517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58518       };
58519     }
58520   }
58521
58522   jresult = (void *)result;
58523   return jresult;
58524 }
58525
58526
58527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58528   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58529
58530   arg1 = (Dali::Timer *)jarg1;
58531   {
58532     try {
58533       delete arg1;
58534     } catch (std::out_of_range& e) {
58535       {
58536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58537       };
58538     } catch (std::exception& e) {
58539       {
58540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58541       };
58542     } catch (Dali::DaliException e) {
58543       {
58544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58545       };
58546     } catch (...) {
58547       {
58548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58549       };
58550     }
58551   }
58552
58553 }
58554
58555
58556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58557   void * jresult ;
58558   Dali::BaseHandle arg1 ;
58559   Dali::BaseHandle *argp1 ;
58560   Dali::Timer result;
58561
58562   argp1 = (Dali::BaseHandle *)jarg1;
58563   if (!argp1) {
58564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58565     return 0;
58566   }
58567   arg1 = *argp1;
58568   {
58569     try {
58570       result = Dali::Timer::DownCast(arg1);
58571     } catch (std::out_of_range& e) {
58572       {
58573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58574       };
58575     } catch (std::exception& e) {
58576       {
58577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58578       };
58579     } catch (Dali::DaliException e) {
58580       {
58581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58582       };
58583     } catch (...) {
58584       {
58585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58586       };
58587     }
58588   }
58589
58590   jresult = new Dali::Timer((const Dali::Timer &)result);
58591   return jresult;
58592 }
58593
58594
58595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58596   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58597
58598   arg1 = (Dali::Timer *)jarg1;
58599   {
58600     try {
58601       (arg1)->Start();
58602     } catch (std::out_of_range& e) {
58603       {
58604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58605       };
58606     } catch (std::exception& e) {
58607       {
58608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58609       };
58610     } catch (Dali::DaliException e) {
58611       {
58612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58613       };
58614     } catch (...) {
58615       {
58616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58617       };
58618     }
58619   }
58620
58621 }
58622
58623
58624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58625   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58626
58627   arg1 = (Dali::Timer *)jarg1;
58628   {
58629     try {
58630       (arg1)->Stop();
58631     } catch (std::out_of_range& e) {
58632       {
58633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58634       };
58635     } catch (std::exception& e) {
58636       {
58637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58638       };
58639     } catch (Dali::DaliException e) {
58640       {
58641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58642       };
58643     } catch (...) {
58644       {
58645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58646       };
58647     }
58648   }
58649
58650 }
58651
58652
58653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58654   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58655   unsigned int arg2 ;
58656
58657   arg1 = (Dali::Timer *)jarg1;
58658   arg2 = (unsigned int)jarg2;
58659   {
58660     try {
58661       (arg1)->SetInterval(arg2);
58662     } catch (std::out_of_range& e) {
58663       {
58664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58665       };
58666     } catch (std::exception& e) {
58667       {
58668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58669       };
58670     } catch (Dali::DaliException e) {
58671       {
58672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58673       };
58674     } catch (...) {
58675       {
58676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58677       };
58678     }
58679   }
58680
58681 }
58682
58683
58684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58685   unsigned int jresult ;
58686   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58687   unsigned int result;
58688
58689   arg1 = (Dali::Timer *)jarg1;
58690   {
58691     try {
58692       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58693     } catch (std::out_of_range& e) {
58694       {
58695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58696       };
58697     } catch (std::exception& e) {
58698       {
58699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58700       };
58701     } catch (Dali::DaliException e) {
58702       {
58703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58704       };
58705     } catch (...) {
58706       {
58707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58708       };
58709     }
58710   }
58711
58712   jresult = result;
58713   return jresult;
58714 }
58715
58716
58717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58718   unsigned int jresult ;
58719   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58720   bool result;
58721
58722   arg1 = (Dali::Timer *)jarg1;
58723   {
58724     try {
58725       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58726     } catch (std::out_of_range& e) {
58727       {
58728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58729       };
58730     } catch (std::exception& e) {
58731       {
58732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58733       };
58734     } catch (Dali::DaliException e) {
58735       {
58736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58737       };
58738     } catch (...) {
58739       {
58740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58741       };
58742     }
58743   }
58744
58745   jresult = result;
58746   return jresult;
58747 }
58748
58749
58750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58751   void * jresult ;
58752   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58753   Dali::Timer::TimerSignalType *result = 0 ;
58754
58755   arg1 = (Dali::Timer *)jarg1;
58756   {
58757     try {
58758       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58759     } catch (std::out_of_range& e) {
58760       {
58761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58762       };
58763     } catch (std::exception& e) {
58764       {
58765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58766       };
58767     } catch (Dali::DaliException e) {
58768       {
58769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58770       };
58771     } catch (...) {
58772       {
58773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58774       };
58775     }
58776   }
58777
58778   jresult = (void *)result;
58779   return jresult;
58780 }
58781
58782
58783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58784   void * jresult ;
58785   Dali::DragAndDropDetector *result = 0 ;
58786
58787   {
58788     try {
58789       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58790     } catch (std::out_of_range& e) {
58791       {
58792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58793       };
58794     } catch (std::exception& e) {
58795       {
58796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58797       };
58798     } catch (Dali::DaliException e) {
58799       {
58800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58801       };
58802     } catch (...) {
58803       {
58804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58805       };
58806     }
58807   }
58808
58809   jresult = (void *)result;
58810   return jresult;
58811 }
58812
58813
58814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58815   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58816
58817   arg1 = (Dali::DragAndDropDetector *)jarg1;
58818   {
58819     try {
58820       delete arg1;
58821     } catch (std::out_of_range& e) {
58822       {
58823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58824       };
58825     } catch (std::exception& e) {
58826       {
58827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58828       };
58829     } catch (Dali::DaliException e) {
58830       {
58831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58832       };
58833     } catch (...) {
58834       {
58835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58836       };
58837     }
58838   }
58839
58840 }
58841
58842
58843 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58844   char * jresult ;
58845   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58846   std::string *result = 0 ;
58847
58848   arg1 = (Dali::DragAndDropDetector *)jarg1;
58849   {
58850     try {
58851       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58852     } catch (std::out_of_range& e) {
58853       {
58854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58855       };
58856     } catch (std::exception& e) {
58857       {
58858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58859       };
58860     } catch (Dali::DaliException e) {
58861       {
58862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58863       };
58864     } catch (...) {
58865       {
58866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58867       };
58868     }
58869   }
58870
58871   jresult = SWIG_csharp_string_callback(result->c_str());
58872   return jresult;
58873 }
58874
58875
58876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58877   void * jresult ;
58878   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58879   Dali::Vector2 result;
58880
58881   arg1 = (Dali::DragAndDropDetector *)jarg1;
58882   {
58883     try {
58884       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58885     } catch (std::out_of_range& e) {
58886       {
58887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58888       };
58889     } catch (std::exception& e) {
58890       {
58891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58892       };
58893     } catch (Dali::DaliException e) {
58894       {
58895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58896       };
58897     } catch (...) {
58898       {
58899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58900       };
58901     }
58902   }
58903
58904   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58905   return jresult;
58906 }
58907
58908
58909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58910   void * jresult ;
58911   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58912   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58913
58914   arg1 = (Dali::DragAndDropDetector *)jarg1;
58915   {
58916     try {
58917       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58918     } catch (std::out_of_range& e) {
58919       {
58920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58921       };
58922     } catch (std::exception& e) {
58923       {
58924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58925       };
58926     } catch (Dali::DaliException e) {
58927       {
58928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58929       };
58930     } catch (...) {
58931       {
58932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58933       };
58934     }
58935   }
58936
58937   jresult = (void *)result;
58938   return jresult;
58939 }
58940
58941
58942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58943   void * jresult ;
58944   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58945   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58946
58947   arg1 = (Dali::DragAndDropDetector *)jarg1;
58948   {
58949     try {
58950       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58951     } catch (std::out_of_range& e) {
58952       {
58953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58954       };
58955     } catch (std::exception& e) {
58956       {
58957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58958       };
58959     } catch (Dali::DaliException e) {
58960       {
58961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58962       };
58963     } catch (...) {
58964       {
58965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58966       };
58967     }
58968   }
58969
58970   jresult = (void *)result;
58971   return jresult;
58972 }
58973
58974
58975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58976   void * jresult ;
58977   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58978   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58979
58980   arg1 = (Dali::DragAndDropDetector *)jarg1;
58981   {
58982     try {
58983       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58984     } catch (std::out_of_range& e) {
58985       {
58986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58987       };
58988     } catch (std::exception& e) {
58989       {
58990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58991       };
58992     } catch (Dali::DaliException e) {
58993       {
58994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58995       };
58996     } catch (...) {
58997       {
58998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58999       };
59000     }
59001   }
59002
59003   jresult = (void *)result;
59004   return jresult;
59005 }
59006
59007
59008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
59009   void * jresult ;
59010   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
59011   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
59012
59013   arg1 = (Dali::DragAndDropDetector *)jarg1;
59014   {
59015     try {
59016       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
59017     } catch (std::out_of_range& e) {
59018       {
59019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59020       };
59021     } catch (std::exception& e) {
59022       {
59023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59024       };
59025     } catch (Dali::DaliException e) {
59026       {
59027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59028       };
59029     } catch (...) {
59030       {
59031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59032       };
59033     }
59034   }
59035
59036   jresult = (void *)result;
59037   return jresult;
59038 }
59039
59040
59041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
59042   void * jresult ;
59043   Dali::ApplicationExtensions *result = 0 ;
59044
59045   {
59046     try {
59047       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
59048     } catch (std::out_of_range& e) {
59049       {
59050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59051       };
59052     } catch (std::exception& e) {
59053       {
59054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59055       };
59056     } catch (Dali::DaliException e) {
59057       {
59058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59059       };
59060     } catch (...) {
59061       {
59062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59063       };
59064     }
59065   }
59066
59067   jresult = (void *)result;
59068   return jresult;
59069 }
59070
59071
59072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
59073   void * jresult ;
59074   Dali::Application *arg1 = (Dali::Application *) 0 ;
59075   Dali::ApplicationExtensions *result = 0 ;
59076
59077   arg1 = (Dali::Application *)jarg1;
59078   {
59079     try {
59080       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
59081     } catch (std::out_of_range& e) {
59082       {
59083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59084       };
59085     } catch (std::exception& e) {
59086       {
59087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59088       };
59089     } catch (Dali::DaliException e) {
59090       {
59091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59092       };
59093     } catch (...) {
59094       {
59095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59096       };
59097     }
59098   }
59099
59100   jresult = (void *)result;
59101   return jresult;
59102 }
59103
59104
59105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
59106   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59107
59108   arg1 = (Dali::ApplicationExtensions *)jarg1;
59109   {
59110     try {
59111       delete arg1;
59112     } catch (std::out_of_range& e) {
59113       {
59114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59115       };
59116     } catch (std::exception& e) {
59117       {
59118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59119       };
59120     } catch (Dali::DaliException e) {
59121       {
59122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59123       };
59124     } catch (...) {
59125       {
59126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59127       };
59128     }
59129   }
59130
59131 }
59132
59133
59134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
59135   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59136
59137   arg1 = (Dali::ApplicationExtensions *)jarg1;
59138   {
59139     try {
59140       (arg1)->Init();
59141     } catch (std::out_of_range& e) {
59142       {
59143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59144       };
59145     } catch (std::exception& e) {
59146       {
59147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59148       };
59149     } catch (Dali::DaliException e) {
59150       {
59151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59152       };
59153     } catch (...) {
59154       {
59155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59156       };
59157     }
59158   }
59159
59160 }
59161
59162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
59163   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59164
59165   arg1 = (Dali::ApplicationExtensions *)jarg1;
59166   {
59167     try {
59168       (arg1)->Start();
59169     } catch (std::out_of_range& e) {
59170       {
59171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59172       };
59173     } catch (std::exception& e) {
59174       {
59175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59176       };
59177     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
59178   }
59179 }
59180
59181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
59182   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59183
59184   arg1 = (Dali::ApplicationExtensions *)jarg1;
59185   {
59186     try {
59187       (arg1)->Terminate();
59188     } catch (std::out_of_range& e) {
59189       {
59190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59191       };
59192     } catch (std::exception& e) {
59193       {
59194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59195       };
59196     } catch (Dali::DaliException e) {
59197       {
59198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59199       };
59200     } catch (...) {
59201       {
59202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59203       };
59204     }
59205   }
59206
59207 }
59208
59209
59210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59211   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59212
59213   arg1 = (Dali::ApplicationExtensions *)jarg1;
59214   {
59215     try {
59216       (arg1)->Pause();
59217     } catch (std::out_of_range& e) {
59218       {
59219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59220       };
59221     } catch (std::exception& e) {
59222       {
59223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59224       };
59225     } catch (Dali::DaliException e) {
59226       {
59227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59228       };
59229     } catch (...) {
59230       {
59231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59232       };
59233     }
59234   }
59235
59236 }
59237
59238
59239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59240   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59241
59242   arg1 = (Dali::ApplicationExtensions *)jarg1;
59243   {
59244     try {
59245       (arg1)->Resume();
59246     } catch (std::out_of_range& e) {
59247       {
59248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59249       };
59250     } catch (std::exception& e) {
59251       {
59252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59253       };
59254     } catch (Dali::DaliException e) {
59255       {
59256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59257       };
59258     } catch (...) {
59259       {
59260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59261       };
59262     }
59263   }
59264
59265 }
59266
59267
59268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59269   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59270
59271   arg1 = (Dali::ApplicationExtensions *)jarg1;
59272   {
59273     try {
59274       (arg1)->LanguageChange();
59275     } catch (std::out_of_range& e) {
59276       {
59277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59278       };
59279     } catch (std::exception& e) {
59280       {
59281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59282       };
59283     } catch (Dali::DaliException e) {
59284       {
59285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59286       };
59287     } catch (...) {
59288       {
59289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59290       };
59291     }
59292   }
59293
59294 }
59295
59296
59297
59298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59299   unsigned int jresult ;
59300   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59301   bool result;
59302
59303   arg1 = (Dali::Signal< bool () > *)jarg1;
59304   {
59305     try {
59306       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59307     } catch (std::out_of_range& e) {
59308       {
59309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59310       };
59311     } catch (std::exception& e) {
59312       {
59313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59314       };
59315     } catch (Dali::DaliException e) {
59316       {
59317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59318       };
59319     } catch (...) {
59320       {
59321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59322       };
59323     }
59324   }
59325
59326   jresult = result;
59327   return jresult;
59328 }
59329
59330
59331 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59332   unsigned long jresult ;
59333   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59334   std::size_t result;
59335
59336   arg1 = (Dali::Signal< bool () > *)jarg1;
59337   {
59338     try {
59339       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59340     } catch (std::out_of_range& e) {
59341       {
59342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59343       };
59344     } catch (std::exception& e) {
59345       {
59346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59347       };
59348     } catch (Dali::DaliException e) {
59349       {
59350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59351       };
59352     } catch (...) {
59353       {
59354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59355       };
59356     }
59357   }
59358
59359   jresult = (unsigned long)result;
59360   return jresult;
59361 }
59362
59363
59364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59365   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59366   bool (*arg2)() = (bool (*)()) 0 ;
59367
59368   arg1 = (Dali::Signal< bool () > *)jarg1;
59369   arg2 = (bool (*)())jarg2;
59370   {
59371     try {
59372       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59373     } catch (std::out_of_range& e) {
59374       {
59375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59376       };
59377     } catch (std::exception& e) {
59378       {
59379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59380       };
59381     } catch (Dali::DaliException e) {
59382       {
59383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59384       };
59385     } catch (...) {
59386       {
59387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59388       };
59389     }
59390   }
59391
59392 }
59393
59394
59395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59396   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59397   bool (*arg2)() = (bool (*)()) 0 ;
59398
59399   arg1 = (Dali::Signal< bool () > *)jarg1;
59400   arg2 = (bool (*)())jarg2;
59401   {
59402     try {
59403       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59404     } catch (std::out_of_range& e) {
59405       {
59406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59407       };
59408     } catch (std::exception& e) {
59409       {
59410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59411       };
59412     } catch (Dali::DaliException e) {
59413       {
59414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59415       };
59416     } catch (...) {
59417       {
59418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59419       };
59420     }
59421   }
59422
59423 }
59424
59425
59426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59427   unsigned int jresult ;
59428   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59429   bool result;
59430
59431   arg1 = (Dali::Signal< bool () > *)jarg1;
59432   {
59433     try {
59434       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59435     } catch (std::out_of_range& e) {
59436       {
59437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59438       };
59439     } catch (std::exception& e) {
59440       {
59441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59442       };
59443     } catch (Dali::DaliException e) {
59444       {
59445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59446       };
59447     } catch (...) {
59448       {
59449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59450       };
59451     }
59452   }
59453
59454   jresult = result;
59455   return jresult;
59456 }
59457
59458
59459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59460   void * jresult ;
59461   Dali::Signal< bool () > *result = 0 ;
59462
59463   {
59464     try {
59465       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59466     } catch (std::out_of_range& e) {
59467       {
59468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59469       };
59470     } catch (std::exception& e) {
59471       {
59472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59473       };
59474     } catch (Dali::DaliException e) {
59475       {
59476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59477       };
59478     } catch (...) {
59479       {
59480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59481       };
59482     }
59483   }
59484
59485   jresult = (void *)result;
59486   return jresult;
59487 }
59488
59489
59490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59491   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59492
59493   arg1 = (Dali::Signal< bool () > *)jarg1;
59494   {
59495     try {
59496       delete arg1;
59497     } catch (std::out_of_range& e) {
59498       {
59499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59500       };
59501     } catch (std::exception& e) {
59502       {
59503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59504       };
59505     } catch (Dali::DaliException e) {
59506       {
59507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59508       };
59509     } catch (...) {
59510       {
59511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59512       };
59513     }
59514   }
59515
59516 }
59517
59518
59519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59520   int jresult ;
59521   int result;
59522
59523   {
59524     try {
59525       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59526     } catch (std::out_of_range& e) {
59527       {
59528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59529       };
59530     } catch (std::exception& e) {
59531       {
59532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59533       };
59534     } catch (Dali::DaliException e) {
59535       {
59536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59537       };
59538     } catch (...) {
59539       {
59540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59541       };
59542     }
59543   }
59544
59545   jresult = (int)result;
59546   return jresult;
59547 }
59548
59549
59550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59551   int jresult ;
59552   int result;
59553
59554   {
59555     try {
59556       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59557     } catch (std::out_of_range& e) {
59558       {
59559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59560       };
59561     } catch (std::exception& e) {
59562       {
59563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59564       };
59565     } catch (Dali::DaliException e) {
59566       {
59567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59568       };
59569     } catch (...) {
59570       {
59571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59572       };
59573     }
59574   }
59575
59576   jresult = (int)result;
59577   return jresult;
59578 }
59579
59580
59581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59582   int jresult ;
59583   int result;
59584
59585   {
59586     try {
59587       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59588     } catch (std::out_of_range& e) {
59589       {
59590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59591       };
59592     } catch (std::exception& e) {
59593       {
59594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59595       };
59596     } catch (Dali::DaliException e) {
59597       {
59598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59599       };
59600     } catch (...) {
59601       {
59602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59603       };
59604     }
59605   }
59606
59607   jresult = (int)result;
59608   return jresult;
59609 }
59610
59611
59612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59613   int jresult ;
59614   int result;
59615
59616   {
59617     try {
59618       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59619     } catch (std::out_of_range& e) {
59620       {
59621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59622       };
59623     } catch (std::exception& e) {
59624       {
59625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59626       };
59627     } catch (Dali::DaliException e) {
59628       {
59629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59630       };
59631     } catch (...) {
59632       {
59633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59634       };
59635     }
59636   }
59637
59638   jresult = (int)result;
59639   return jresult;
59640 }
59641
59642
59643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59644   int jresult ;
59645   int result;
59646
59647   {
59648     try {
59649       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59650     } catch (std::out_of_range& e) {
59651       {
59652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59653       };
59654     } catch (std::exception& e) {
59655       {
59656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59657       };
59658     } catch (Dali::DaliException e) {
59659       {
59660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59661       };
59662     } catch (...) {
59663       {
59664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59665       };
59666     }
59667   }
59668
59669   jresult = (int)result;
59670   return jresult;
59671 }
59672
59673
59674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59675   int jresult ;
59676   int result;
59677
59678   {
59679     try {
59680       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59681     } catch (std::out_of_range& e) {
59682       {
59683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59684       };
59685     } catch (std::exception& e) {
59686       {
59687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59688       };
59689     } catch (Dali::DaliException e) {
59690       {
59691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59692       };
59693     } catch (...) {
59694       {
59695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59696       };
59697     }
59698   }
59699
59700   jresult = (int)result;
59701   return jresult;
59702 }
59703
59704
59705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59706   int jresult ;
59707   int result;
59708
59709   {
59710     try {
59711       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59712     } catch (std::out_of_range& e) {
59713       {
59714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59715       };
59716     } catch (std::exception& e) {
59717       {
59718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59719       };
59720     } catch (Dali::DaliException e) {
59721       {
59722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59723       };
59724     } catch (...) {
59725       {
59726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59727       };
59728     }
59729   }
59730
59731   jresult = (int)result;
59732   return jresult;
59733 }
59734
59735
59736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59737   int jresult ;
59738   int result;
59739
59740   {
59741     try {
59742       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59743     } catch (std::out_of_range& e) {
59744       {
59745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59746       };
59747     } catch (std::exception& e) {
59748       {
59749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59750       };
59751     } catch (Dali::DaliException e) {
59752       {
59753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59754       };
59755     } catch (...) {
59756       {
59757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59758       };
59759     }
59760   }
59761
59762   jresult = (int)result;
59763   return jresult;
59764 }
59765
59766
59767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59768   int jresult ;
59769   int result;
59770
59771   {
59772     try {
59773       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59774     } catch (std::out_of_range& e) {
59775       {
59776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59777       };
59778     } catch (std::exception& e) {
59779       {
59780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59781       };
59782     } catch (Dali::DaliException e) {
59783       {
59784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59785       };
59786     } catch (...) {
59787       {
59788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59789       };
59790     }
59791   }
59792
59793   jresult = (int)result;
59794   return jresult;
59795 }
59796
59797
59798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59799   int jresult ;
59800   int result;
59801
59802   {
59803     try {
59804       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59805     } catch (std::out_of_range& e) {
59806       {
59807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59808       };
59809     } catch (std::exception& e) {
59810       {
59811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59812       };
59813     } catch (Dali::DaliException e) {
59814       {
59815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59816       };
59817     } catch (...) {
59818       {
59819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59820       };
59821     }
59822   }
59823
59824   jresult = (int)result;
59825   return jresult;
59826 }
59827
59828
59829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59830   int jresult ;
59831   int result;
59832
59833   {
59834     try {
59835       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59836     } catch (std::out_of_range& e) {
59837       {
59838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59839       };
59840     } catch (std::exception& e) {
59841       {
59842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59843       };
59844     } catch (Dali::DaliException e) {
59845       {
59846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59847       };
59848     } catch (...) {
59849       {
59850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59851       };
59852     }
59853   }
59854
59855   jresult = (int)result;
59856   return jresult;
59857 }
59858
59859
59860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59861   int jresult ;
59862   int result;
59863
59864   {
59865     try {
59866       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59867     } catch (std::out_of_range& e) {
59868       {
59869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59870       };
59871     } catch (std::exception& e) {
59872       {
59873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59874       };
59875     } catch (Dali::DaliException e) {
59876       {
59877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59878       };
59879     } catch (...) {
59880       {
59881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59882       };
59883     }
59884   }
59885
59886   jresult = (int)result;
59887   return jresult;
59888 }
59889
59890
59891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59892   int jresult ;
59893   int result;
59894
59895   {
59896     try {
59897       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59898     } catch (std::out_of_range& e) {
59899       {
59900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59901       };
59902     } catch (std::exception& e) {
59903       {
59904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59905       };
59906     } catch (Dali::DaliException e) {
59907       {
59908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59909       };
59910     } catch (...) {
59911       {
59912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59913       };
59914     }
59915   }
59916
59917   jresult = (int)result;
59918   return jresult;
59919 }
59920
59921
59922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59923   int jresult ;
59924   int result;
59925
59926   {
59927     try {
59928       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59929     } catch (std::out_of_range& e) {
59930       {
59931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59932       };
59933     } catch (std::exception& e) {
59934       {
59935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59936       };
59937     } catch (Dali::DaliException e) {
59938       {
59939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59940       };
59941     } catch (...) {
59942       {
59943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59944       };
59945     }
59946   }
59947
59948   jresult = (int)result;
59949   return jresult;
59950 }
59951
59952
59953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59954   int jresult ;
59955   int result;
59956
59957   {
59958     try {
59959       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59960     } catch (std::out_of_range& e) {
59961       {
59962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59963       };
59964     } catch (std::exception& e) {
59965       {
59966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59967       };
59968     } catch (Dali::DaliException e) {
59969       {
59970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59971       };
59972     } catch (...) {
59973       {
59974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59975       };
59976     }
59977   }
59978
59979   jresult = (int)result;
59980   return jresult;
59981 }
59982
59983
59984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59985   int jresult ;
59986   int result;
59987
59988   {
59989     try {
59990       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59991     } catch (std::out_of_range& e) {
59992       {
59993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59994       };
59995     } catch (std::exception& e) {
59996       {
59997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59998       };
59999     } catch (Dali::DaliException e) {
60000       {
60001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60002       };
60003     } catch (...) {
60004       {
60005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60006       };
60007     }
60008   }
60009
60010   jresult = (int)result;
60011   return jresult;
60012 }
60013
60014
60015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
60016   int jresult ;
60017   int result;
60018
60019   {
60020     try {
60021       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
60022     } catch (std::out_of_range& e) {
60023       {
60024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60025       };
60026     } catch (std::exception& e) {
60027       {
60028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60029       };
60030     } catch (Dali::DaliException e) {
60031       {
60032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60033       };
60034     } catch (...) {
60035       {
60036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60037       };
60038     }
60039   }
60040
60041   jresult = (int)result;
60042   return jresult;
60043 }
60044
60045
60046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
60047   int jresult ;
60048   int result;
60049
60050   {
60051     try {
60052       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
60053     } catch (std::out_of_range& e) {
60054       {
60055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60056       };
60057     } catch (std::exception& e) {
60058       {
60059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60060       };
60061     } catch (Dali::DaliException e) {
60062       {
60063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60064       };
60065     } catch (...) {
60066       {
60067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60068       };
60069     }
60070   }
60071
60072   jresult = (int)result;
60073   return jresult;
60074 }
60075
60076
60077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
60078   int jresult ;
60079   int result;
60080
60081   {
60082     try {
60083       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
60084     } catch (std::out_of_range& e) {
60085       {
60086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60087       };
60088     } catch (std::exception& e) {
60089       {
60090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60091       };
60092     } catch (Dali::DaliException e) {
60093       {
60094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60095       };
60096     } catch (...) {
60097       {
60098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60099       };
60100     }
60101   }
60102
60103   jresult = (int)result;
60104   return jresult;
60105 }
60106
60107
60108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
60109   int jresult ;
60110   int result;
60111
60112   {
60113     try {
60114       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
60115     } catch (std::out_of_range& e) {
60116       {
60117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60118       };
60119     } catch (std::exception& e) {
60120       {
60121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60122       };
60123     } catch (Dali::DaliException e) {
60124       {
60125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60126       };
60127     } catch (...) {
60128       {
60129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60130       };
60131     }
60132   }
60133
60134   jresult = (int)result;
60135   return jresult;
60136 }
60137
60138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
60139   int jresult ;
60140   int result;
60141
60142   {
60143     try {
60144       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
60145     } catch (std::out_of_range& e) {
60146       {
60147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60148       };
60149     } catch (std::exception& e) {
60150       {
60151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60152       };
60153     } catch (Dali::DaliException e) {
60154       {
60155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60156       };
60157     } catch (...) {
60158       {
60159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60160       };
60161     }
60162   }
60163
60164   jresult = (int)result;
60165   return jresult;
60166 }
60167
60168
60169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
60170   int jresult ;
60171   int result;
60172   {
60173     try
60174     {
60175       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
60176     } catch (std::out_of_range& e) {
60177       {
60178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60179       };
60180     } catch (std::exception& e) {
60181       {
60182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60183       };
60184     } catch (Dali::DaliException e) {
60185       {
60186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60187       };
60188     } catch (...) {
60189       {
60190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60191       };
60192     }
60193   }
60194
60195   jresult = (int)result;
60196   return jresult;
60197 }
60198
60199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
60200   int jresult ;
60201   int result;
60202   {
60203     try
60204     {
60205       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
60206     } catch (std::out_of_range& e) {
60207       {
60208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60209       };
60210     } catch (std::exception& e) {
60211       {
60212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60213       };
60214     } catch (Dali::DaliException e) {
60215       {
60216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60217       };
60218     } catch (...) {
60219       {
60220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60221       };
60222     }
60223   }
60224
60225   jresult = (int)result;
60226   return jresult;
60227 }
60228
60229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60230   int jresult ;
60231   int result;
60232   {
60233     try
60234     {
60235       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
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_LOOP_COUNT_get() {
60260   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
60261 }
60262
60263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60264   int jresult ;
60265   int result;
60266   {
60267     try
60268     {
60269       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60270     } catch (std::out_of_range& e) {
60271       {
60272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60273       };
60274     } catch (std::exception& e) {
60275       {
60276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60277       };
60278     } catch (Dali::DaliException e) {
60279       {
60280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60281       };
60282     } catch (...) {
60283       {
60284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60285       };
60286     }
60287   }
60288
60289   jresult = (int)result;
60290   return jresult;
60291 }
60292
60293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60294   int jresult ;
60295   int result;
60296   {
60297     try
60298     {
60299       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60300     } catch (std::out_of_range& e) {
60301       {
60302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60303       };
60304     } catch (std::exception& e) {
60305       {
60306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60307       };
60308     } catch (Dali::DaliException e) {
60309       {
60310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60311       };
60312     } catch (...) {
60313       {
60314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60315       };
60316     }
60317   }
60318
60319   jresult = (int)result;
60320   return jresult;
60321 }
60322
60323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60324   int jresult ;
60325   int result;
60326
60327   {
60328     try {
60329       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60330     } catch (std::out_of_range& e) {
60331       {
60332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60333       };
60334     } catch (std::exception& e) {
60335       {
60336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60337       };
60338     } catch (Dali::DaliException e) {
60339       {
60340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60341       };
60342     } catch (...) {
60343       {
60344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60345       };
60346     }
60347   }
60348
60349   jresult = (int)result;
60350   return jresult;
60351 }
60352
60353
60354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60355   int jresult ;
60356   int result;
60357
60358   {
60359     try {
60360       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60361     } catch (std::out_of_range& e) {
60362       {
60363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60364       };
60365     } catch (std::exception& e) {
60366       {
60367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60368       };
60369     } catch (Dali::DaliException e) {
60370       {
60371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60372       };
60373     } catch (...) {
60374       {
60375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60376       };
60377     }
60378   }
60379
60380   jresult = (int)result;
60381   return jresult;
60382 }
60383
60384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60385   int jresult ;
60386   int result;
60387   {
60388     try
60389     {
60390       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60391     } catch (std::out_of_range& e) {
60392       {
60393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60394       };
60395     } catch (std::exception& e) {
60396       {
60397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60398       };
60399     } catch (...) {
60400       {
60401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60402       };
60403     }
60404   }
60405   jresult = (int)result;
60406   return jresult;
60407 }
60408
60409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60410   int jresult ;
60411   int result;
60412   {
60413     try
60414     {
60415       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60416     } catch (std::out_of_range& e) {
60417       {
60418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60419       };
60420     } catch (std::exception& e) {
60421       {
60422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60423       };
60424     } catch (...) {
60425       {
60426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60427       };
60428     }
60429   }
60430   jresult = (int)result;
60431   return jresult;
60432 }
60433
60434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60435   int jresult ;
60436   int result;
60437   {
60438     try
60439     {
60440       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60441     } catch (std::out_of_range& e) {
60442       {
60443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60444       };
60445     } catch (std::exception& e) {
60446       {
60447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60448       };
60449     } catch (...) {
60450       {
60451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60452       };
60453     }
60454   }
60455   jresult = (int)result;
60456   return jresult;
60457 }
60458
60459
60460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60461   int jresult ;
60462   int result;
60463   {
60464     try
60465     {
60466       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60467     } catch (std::out_of_range& e) {
60468       {
60469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60470       };
60471     } catch (std::exception& e) {
60472       {
60473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60474       };
60475     } catch (...) {
60476       {
60477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60478       };
60479     }
60480   }
60481   jresult = (int)result;
60482   return jresult;
60483 }
60484
60485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60486   int jresult ;
60487   int result;
60488   {
60489     try
60490     {
60491       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60492     } catch (std::out_of_range& e) {
60493       {
60494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60495       };
60496     } catch (std::exception& e) {
60497       {
60498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60499       };
60500     } catch (...) {
60501       {
60502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60503       };
60504     }
60505   }
60506   jresult = (int)result;
60507   return jresult;
60508 }
60509
60510
60511
60512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60513   int jresult ;
60514   int result;
60515
60516   {
60517     try {
60518       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60519     } catch (std::out_of_range& e) {
60520       {
60521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60522       };
60523     } catch (std::exception& e) {
60524       {
60525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60526       };
60527     } catch (Dali::DaliException e) {
60528       {
60529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60530       };
60531     } catch (...) {
60532       {
60533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60534       };
60535     }
60536   }
60537
60538   jresult = (int)result;
60539   return jresult;
60540 }
60541
60542
60543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60544   int jresult ;
60545   int result;
60546
60547   {
60548     try {
60549       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60550     } catch (std::out_of_range& e) {
60551       {
60552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60553       };
60554     } catch (std::exception& e) {
60555       {
60556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60557       };
60558     } catch (Dali::DaliException e) {
60559       {
60560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60561       };
60562     } catch (...) {
60563       {
60564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60565       };
60566     }
60567   }
60568
60569   jresult = (int)result;
60570   return jresult;
60571 }
60572
60573
60574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60575   int jresult ;
60576   int result;
60577
60578   {
60579     try {
60580       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60581     } catch (std::out_of_range& e) {
60582       {
60583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60584       };
60585     } catch (std::exception& e) {
60586       {
60587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60588       };
60589     } catch (Dali::DaliException e) {
60590       {
60591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60592       };
60593     } catch (...) {
60594       {
60595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60596       };
60597     }
60598   }
60599
60600   jresult = (int)result;
60601   return jresult;
60602 }
60603
60604
60605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60606   int jresult ;
60607   int result;
60608
60609   {
60610     try {
60611       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60612     } catch (std::out_of_range& e) {
60613       {
60614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60615       };
60616     } catch (std::exception& e) {
60617       {
60618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60619       };
60620     } catch (Dali::DaliException e) {
60621       {
60622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60623       };
60624     } catch (...) {
60625       {
60626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60627       };
60628     }
60629   }
60630
60631   jresult = (int)result;
60632   return jresult;
60633 }
60634
60635
60636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60637   int jresult ;
60638   int result;
60639
60640   {
60641     try {
60642       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60643     } catch (std::out_of_range& e) {
60644       {
60645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60646       };
60647     } catch (std::exception& e) {
60648       {
60649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60650       };
60651     } catch (Dali::DaliException e) {
60652       {
60653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60654       };
60655     } catch (...) {
60656       {
60657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60658       };
60659     }
60660   }
60661
60662   jresult = (int)result;
60663   return jresult;
60664 }
60665
60666
60667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60668   int jresult ;
60669   int result;
60670
60671   {
60672     try {
60673       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60674     } catch (std::out_of_range& e) {
60675       {
60676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60677       };
60678     } catch (std::exception& e) {
60679       {
60680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60681       };
60682     } catch (Dali::DaliException e) {
60683       {
60684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60685       };
60686     } catch (...) {
60687       {
60688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60689       };
60690     }
60691   }
60692
60693   jresult = (int)result;
60694   return jresult;
60695 }
60696
60697
60698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60699   int jresult ;
60700   int result;
60701
60702   {
60703     try {
60704       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60705     } catch (std::out_of_range& e) {
60706       {
60707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60708       };
60709     } catch (std::exception& e) {
60710       {
60711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60712       };
60713     } catch (Dali::DaliException e) {
60714       {
60715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60716       };
60717     } catch (...) {
60718       {
60719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60720       };
60721     }
60722   }
60723
60724   jresult = (int)result;
60725   return jresult;
60726 }
60727
60728 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60729   int jresult ;
60730   int result;
60731
60732   {
60733     try {
60734       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60735     } catch (std::out_of_range& e) {
60736       {
60737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60738       };
60739     } catch (std::exception& e) {
60740       {
60741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60742       };
60743     } catch (...) {
60744       {
60745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60746       };
60747     }
60748   }
60749   jresult = (int)result;
60750   return jresult;
60751 }
60752
60753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60754   int jresult ;
60755   int result;
60756
60757   {
60758     try {
60759       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60760     } catch (std::out_of_range& e) {
60761       {
60762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60763       };
60764     } catch (std::exception& e) {
60765       {
60766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60767       };
60768     } catch (Dali::DaliException e) {
60769       {
60770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60771       };
60772     } catch (...) {
60773       {
60774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60775       };
60776     }
60777   }
60778
60779   jresult = (int)result;
60780   return jresult;
60781 }
60782
60783
60784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60785   int jresult ;
60786   int result;
60787
60788   {
60789     try {
60790       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60791     } catch (std::out_of_range& e) {
60792       {
60793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60794       };
60795     } catch (std::exception& e) {
60796       {
60797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60798       };
60799     } catch (Dali::DaliException e) {
60800       {
60801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60802       };
60803     } catch (...) {
60804       {
60805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60806       };
60807     }
60808   }
60809
60810   jresult = (int)result;
60811   return jresult;
60812 }
60813
60814
60815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60816   int jresult ;
60817   int result;
60818
60819   {
60820     try {
60821       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60822     } catch (std::out_of_range& e) {
60823       {
60824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60825       };
60826     } catch (std::exception& e) {
60827       {
60828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60829       };
60830     } catch (Dali::DaliException e) {
60831       {
60832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60833       };
60834     } catch (...) {
60835       {
60836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60837       };
60838     }
60839   }
60840
60841   jresult = (int)result;
60842   return jresult;
60843 }
60844
60845
60846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60847   int jresult ;
60848   int result;
60849
60850   {
60851     try {
60852       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60853     } catch (std::out_of_range& e) {
60854       {
60855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60856       };
60857     } catch (std::exception& e) {
60858       {
60859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60860       };
60861     } catch (Dali::DaliException e) {
60862       {
60863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60864       };
60865     } catch (...) {
60866       {
60867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60868       };
60869     }
60870   }
60871
60872   jresult = (int)result;
60873   return jresult;
60874 }
60875
60876
60877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60878   int jresult ;
60879   int result;
60880
60881   {
60882     try {
60883       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60884     } catch (std::out_of_range& e) {
60885       {
60886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60887       };
60888     } catch (std::exception& e) {
60889       {
60890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60891       };
60892     } catch (Dali::DaliException e) {
60893       {
60894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60895       };
60896     } catch (...) {
60897       {
60898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60899       };
60900     }
60901   }
60902
60903   jresult = (int)result;
60904   return jresult;
60905 }
60906
60907
60908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60909   int jresult ;
60910   int result;
60911
60912   {
60913     try {
60914       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60915     } catch (std::out_of_range& e) {
60916       {
60917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60918       };
60919     } catch (std::exception& e) {
60920       {
60921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60922       };
60923     } catch (Dali::DaliException e) {
60924       {
60925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60926       };
60927     } catch (...) {
60928       {
60929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60930       };
60931     }
60932   }
60933
60934   jresult = (int)result;
60935   return jresult;
60936 }
60937
60938
60939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60940   int jresult ;
60941   int result;
60942
60943   {
60944     try {
60945       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60946     } catch (std::out_of_range& e) {
60947       {
60948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60949       };
60950     } catch (std::exception& e) {
60951       {
60952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60953       };
60954     } catch (Dali::DaliException e) {
60955       {
60956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60957       };
60958     } catch (...) {
60959       {
60960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60961       };
60962     }
60963   }
60964
60965   jresult = (int)result;
60966   return jresult;
60967 }
60968
60969
60970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60971   int jresult ;
60972   int result;
60973
60974   {
60975     try {
60976       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60977     } catch (std::out_of_range& e) {
60978       {
60979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60980       };
60981     } catch (std::exception& e) {
60982       {
60983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60984       };
60985     } catch (Dali::DaliException e) {
60986       {
60987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60988       };
60989     } catch (...) {
60990       {
60991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60992       };
60993     }
60994   }
60995
60996   jresult = (int)result;
60997   return jresult;
60998 }
60999
61000
61001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
61002   int jresult ;
61003   int result;
61004
61005   {
61006     try {
61007       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
61008     } catch (std::out_of_range& e) {
61009       {
61010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61011       };
61012     } catch (std::exception& e) {
61013       {
61014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61015       };
61016     } catch (Dali::DaliException e) {
61017       {
61018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61019       };
61020     } catch (...) {
61021       {
61022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61023       };
61024     }
61025   }
61026
61027   jresult = (int)result;
61028   return jresult;
61029 }
61030
61031
61032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
61033   int jresult ;
61034   int result;
61035
61036   {
61037     try {
61038       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
61039     } catch (std::out_of_range& e) {
61040       {
61041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61042       };
61043     } catch (std::exception& e) {
61044       {
61045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61046       };
61047     } catch (Dali::DaliException e) {
61048       {
61049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61050       };
61051     } catch (...) {
61052       {
61053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61054       };
61055     }
61056   }
61057
61058   jresult = (int)result;
61059   return jresult;
61060 }
61061
61062
61063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
61064   int jresult ;
61065   int result;
61066
61067   {
61068     try {
61069       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
61070     } catch (std::out_of_range& e) {
61071       {
61072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61073       };
61074     } catch (std::exception& e) {
61075       {
61076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61077       };
61078     } catch (Dali::DaliException e) {
61079       {
61080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61081       };
61082     } catch (...) {
61083       {
61084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61085       };
61086     }
61087   }
61088
61089   jresult = (int)result;
61090   return jresult;
61091 }
61092
61093
61094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
61095   int jresult ;
61096   int result;
61097
61098   {
61099     try {
61100       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
61101     } catch (std::out_of_range& e) {
61102       {
61103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61104       };
61105     } catch (std::exception& e) {
61106       {
61107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61108       };
61109     } catch (Dali::DaliException e) {
61110       {
61111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61112       };
61113     } catch (...) {
61114       {
61115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61116       };
61117     }
61118   }
61119
61120   jresult = (int)result;
61121   return jresult;
61122 }
61123
61124
61125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
61126   int jresult ;
61127   int result;
61128
61129   {
61130     try {
61131       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
61132     } catch (std::out_of_range& e) {
61133       {
61134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61135       };
61136     } catch (std::exception& e) {
61137       {
61138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61139       };
61140     } catch (Dali::DaliException e) {
61141       {
61142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61143       };
61144     } catch (...) {
61145       {
61146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61147       };
61148     }
61149   }
61150
61151   jresult = (int)result;
61152   return jresult;
61153 }
61154
61155
61156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
61157   int jresult ;
61158   int result;
61159
61160   {
61161     try {
61162       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
61163     } catch (std::out_of_range& e) {
61164       {
61165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61166       };
61167     } catch (std::exception& e) {
61168       {
61169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61170       };
61171     } catch (Dali::DaliException e) {
61172       {
61173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61174       };
61175     } catch (...) {
61176       {
61177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61178       };
61179     }
61180   }
61181
61182   jresult = (int)result;
61183   return jresult;
61184 }
61185
61186
61187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
61188   int jresult ;
61189   int result;
61190
61191   {
61192     try {
61193       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
61194     } catch (std::out_of_range& e) {
61195       {
61196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61197       };
61198     } catch (std::exception& e) {
61199       {
61200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61201       };
61202     } catch (Dali::DaliException e) {
61203       {
61204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61205       };
61206     } catch (...) {
61207       {
61208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61209       };
61210     }
61211   }
61212
61213   jresult = (int)result;
61214   return jresult;
61215 }
61216
61217
61218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61219   int jresult ;
61220   int result;
61221
61222   {
61223     try {
61224       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61225     } catch (std::out_of_range& e) {
61226       {
61227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61228       };
61229     } catch (std::exception& e) {
61230       {
61231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61232       };
61233     } catch (Dali::DaliException e) {
61234       {
61235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61236       };
61237     } catch (...) {
61238       {
61239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61240       };
61241     }
61242   }
61243
61244   jresult = (int)result;
61245   return jresult;
61246 }
61247
61248
61249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61250   int jresult ;
61251   int result;
61252
61253   {
61254     try {
61255       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61256     } catch (std::out_of_range& e) {
61257       {
61258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61259       };
61260     } catch (std::exception& e) {
61261       {
61262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61263       };
61264     } catch (Dali::DaliException e) {
61265       {
61266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61267       };
61268     } catch (...) {
61269       {
61270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61271       };
61272     }
61273   }
61274
61275   jresult = (int)result;
61276   return jresult;
61277 }
61278
61279
61280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61281   int jresult ;
61282   int result;
61283
61284   {
61285     try {
61286       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61287     } catch (std::out_of_range& e) {
61288       {
61289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61290       };
61291     } catch (std::exception& e) {
61292       {
61293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61294       };
61295     } catch (Dali::DaliException e) {
61296       {
61297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61298       };
61299     } catch (...) {
61300       {
61301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61302       };
61303     }
61304   }
61305
61306   jresult = (int)result;
61307   return jresult;
61308 }
61309
61310
61311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61312   int jresult ;
61313   int result;
61314
61315   {
61316     try {
61317       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61318     } catch (std::out_of_range& e) {
61319       {
61320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61321       };
61322     } catch (std::exception& e) {
61323       {
61324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61325       };
61326     } catch (Dali::DaliException e) {
61327       {
61328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61329       };
61330     } catch (...) {
61331       {
61332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61333       };
61334     }
61335   }
61336
61337   jresult = (int)result;
61338   return jresult;
61339 }
61340
61341
61342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61343   int jresult ;
61344   int result;
61345
61346   {
61347     try {
61348       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61349     } catch (std::out_of_range& e) {
61350       {
61351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61352       };
61353     } catch (std::exception& e) {
61354       {
61355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61356       };
61357     } catch (Dali::DaliException e) {
61358       {
61359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61360       };
61361     } catch (...) {
61362       {
61363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61364       };
61365     }
61366   }
61367
61368   jresult = (int)result;
61369   return jresult;
61370 }
61371
61372
61373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61374   int jresult ;
61375   int result;
61376
61377   {
61378     try {
61379       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61380     } catch (std::out_of_range& e) {
61381       {
61382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61383       };
61384     } catch (std::exception& e) {
61385       {
61386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61387       };
61388     } catch (Dali::DaliException e) {
61389       {
61390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61391       };
61392     } catch (...) {
61393       {
61394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61395       };
61396     }
61397   }
61398
61399   jresult = (int)result;
61400   return jresult;
61401 }
61402
61403
61404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61405   int jresult ;
61406   int result;
61407
61408   {
61409     try {
61410       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61411     } catch (std::out_of_range& e) {
61412       {
61413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61414       };
61415     } catch (std::exception& e) {
61416       {
61417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61418       };
61419     } catch (Dali::DaliException e) {
61420       {
61421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61422       };
61423     } catch (...) {
61424       {
61425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61426       };
61427     }
61428   }
61429
61430   jresult = (int)result;
61431   return jresult;
61432 }
61433
61434
61435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61436   int jresult ;
61437   int result;
61438
61439   {
61440     try {
61441       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61442     } catch (std::out_of_range& e) {
61443       {
61444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61445       };
61446     } catch (std::exception& e) {
61447       {
61448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61449       };
61450     } catch (Dali::DaliException e) {
61451       {
61452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61453       };
61454     } catch (...) {
61455       {
61456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61457       };
61458     }
61459   }
61460
61461   jresult = (int)result;
61462   return jresult;
61463 }
61464
61465
61466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61467   int jresult ;
61468   int result;
61469
61470   {
61471     try {
61472       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61473     } catch (std::out_of_range& e) {
61474       {
61475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61476       };
61477     } catch (std::exception& e) {
61478       {
61479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61480       };
61481     } catch (Dali::DaliException e) {
61482       {
61483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61484       };
61485     } catch (...) {
61486       {
61487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61488       };
61489     }
61490   }
61491
61492   jresult = (int)result;
61493   return jresult;
61494 }
61495
61496
61497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61498   int jresult ;
61499   int result;
61500
61501   {
61502     try {
61503       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61504     } catch (std::out_of_range& e) {
61505       {
61506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61507       };
61508     } catch (std::exception& e) {
61509       {
61510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61511       };
61512     } catch (Dali::DaliException e) {
61513       {
61514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61515       };
61516     } catch (...) {
61517       {
61518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61519       };
61520     }
61521   }
61522
61523   jresult = (int)result;
61524   return jresult;
61525 }
61526
61527
61528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61529   int jresult ;
61530   int result;
61531
61532   {
61533     try {
61534       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61535     } catch (std::out_of_range& e) {
61536       {
61537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61538       };
61539     } catch (std::exception& e) {
61540       {
61541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61542       };
61543     } catch (Dali::DaliException e) {
61544       {
61545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61546       };
61547     } catch (...) {
61548       {
61549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61550       };
61551     }
61552   }
61553
61554   jresult = (int)result;
61555   return jresult;
61556 }
61557
61558
61559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61560   int jresult ;
61561   int result;
61562
61563   {
61564     try {
61565       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61566     } catch (std::out_of_range& e) {
61567       {
61568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61569       };
61570     } catch (std::exception& e) {
61571       {
61572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61573       };
61574     } catch (Dali::DaliException e) {
61575       {
61576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61577       };
61578     } catch (...) {
61579       {
61580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61581       };
61582     }
61583   }
61584
61585   jresult = (int)result;
61586   return jresult;
61587 }
61588
61589
61590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61591   int jresult ;
61592   int result;
61593
61594   {
61595     try {
61596       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61597     } catch (std::out_of_range& e) {
61598       {
61599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61600       };
61601     } catch (std::exception& e) {
61602       {
61603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61604       };
61605     } catch (Dali::DaliException e) {
61606       {
61607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61608       };
61609     } catch (...) {
61610       {
61611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61612       };
61613     }
61614   }
61615
61616   jresult = (int)result;
61617   return jresult;
61618 }
61619
61620
61621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61622   void * jresult ;
61623   Dali::Toolkit::Builder *result = 0 ;
61624
61625   {
61626     try {
61627       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61628     } catch (std::out_of_range& e) {
61629       {
61630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61631       };
61632     } catch (std::exception& e) {
61633       {
61634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61635       };
61636     } catch (Dali::DaliException e) {
61637       {
61638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61639       };
61640     } catch (...) {
61641       {
61642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61643       };
61644     }
61645   }
61646
61647   jresult = (void *)result;
61648   return jresult;
61649 }
61650
61651
61652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61653   void * jresult ;
61654   Dali::Toolkit::Builder result;
61655
61656   {
61657     try {
61658       result = Dali::Toolkit::Builder::New();
61659     } catch (std::out_of_range& e) {
61660       {
61661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61662       };
61663     } catch (std::exception& e) {
61664       {
61665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61666       };
61667     } catch (Dali::DaliException e) {
61668       {
61669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61670       };
61671     } catch (...) {
61672       {
61673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61674       };
61675     }
61676   }
61677
61678   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61679   return jresult;
61680 }
61681
61682
61683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61684   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61685
61686   arg1 = (Dali::Toolkit::Builder *)jarg1;
61687   {
61688     try {
61689       delete arg1;
61690     } catch (std::out_of_range& e) {
61691       {
61692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61693       };
61694     } catch (std::exception& e) {
61695       {
61696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61697       };
61698     } catch (Dali::DaliException e) {
61699       {
61700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61701       };
61702     } catch (...) {
61703       {
61704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61705       };
61706     }
61707   }
61708
61709 }
61710
61711
61712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61713   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61714   std::string *arg2 = 0 ;
61715   Dali::Toolkit::Builder::UIFormat arg3 ;
61716
61717   arg1 = (Dali::Toolkit::Builder *)jarg1;
61718   if (!jarg2) {
61719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61720     return ;
61721   }
61722   std::string arg2_str(jarg2);
61723   arg2 = &arg2_str;
61724   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61725   {
61726     try {
61727       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61728     } catch (std::out_of_range& e) {
61729       {
61730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61731       };
61732     } catch (std::exception& e) {
61733       {
61734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61735       };
61736     } catch (Dali::DaliException e) {
61737       {
61738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61739       };
61740     } catch (...) {
61741       {
61742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61743       };
61744     }
61745   }
61746
61747
61748   //argout typemap for const std::string&
61749
61750 }
61751
61752
61753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61754   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61755   std::string *arg2 = 0 ;
61756
61757   arg1 = (Dali::Toolkit::Builder *)jarg1;
61758   if (!jarg2) {
61759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61760     return ;
61761   }
61762   std::string arg2_str(jarg2);
61763   arg2 = &arg2_str;
61764   {
61765     try {
61766       (arg1)->LoadFromString((std::string const &)*arg2);
61767     } catch (std::out_of_range& e) {
61768       {
61769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61770       };
61771     } catch (std::exception& e) {
61772       {
61773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61774       };
61775     } catch (Dali::DaliException e) {
61776       {
61777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61778       };
61779     } catch (...) {
61780       {
61781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61782       };
61783     }
61784   }
61785
61786
61787   //argout typemap for const std::string&
61788
61789 }
61790
61791
61792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61793   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61794   Dali::Property::Map *arg2 = 0 ;
61795
61796   arg1 = (Dali::Toolkit::Builder *)jarg1;
61797   arg2 = (Dali::Property::Map *)jarg2;
61798   if (!arg2) {
61799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61800     return ;
61801   }
61802   {
61803     try {
61804       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61805     } catch (std::out_of_range& e) {
61806       {
61807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61808       };
61809     } catch (std::exception& e) {
61810       {
61811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61812       };
61813     } catch (Dali::DaliException e) {
61814       {
61815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61816       };
61817     } catch (...) {
61818       {
61819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61820       };
61821     }
61822   }
61823
61824 }
61825
61826
61827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61828   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61829   std::string *arg2 = 0 ;
61830   Dali::Property::Value *arg3 = 0 ;
61831
61832   arg1 = (Dali::Toolkit::Builder *)jarg1;
61833   if (!jarg2) {
61834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61835     return ;
61836   }
61837   std::string arg2_str(jarg2);
61838   arg2 = &arg2_str;
61839   arg3 = (Dali::Property::Value *)jarg3;
61840   if (!arg3) {
61841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61842     return ;
61843   }
61844   {
61845     try {
61846       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61847     } catch (std::out_of_range& e) {
61848       {
61849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61850       };
61851     } catch (std::exception& e) {
61852       {
61853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61854       };
61855     } catch (Dali::DaliException e) {
61856       {
61857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61858       };
61859     } catch (...) {
61860       {
61861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61862       };
61863     }
61864   }
61865
61866
61867   //argout typemap for const std::string&
61868
61869 }
61870
61871
61872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61873   void * jresult ;
61874   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61875   Dali::Property::Map *result = 0 ;
61876
61877   arg1 = (Dali::Toolkit::Builder *)jarg1;
61878   {
61879     try {
61880       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61881     } catch (std::out_of_range& e) {
61882       {
61883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61884       };
61885     } catch (std::exception& e) {
61886       {
61887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61888       };
61889     } catch (Dali::DaliException e) {
61890       {
61891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61892       };
61893     } catch (...) {
61894       {
61895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61896       };
61897     }
61898   }
61899
61900   jresult = (void *)result;
61901   return jresult;
61902 }
61903
61904
61905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61906   void * jresult ;
61907   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61908   std::string *arg2 = 0 ;
61909   Dali::Property::Value *result = 0 ;
61910
61911   arg1 = (Dali::Toolkit::Builder *)jarg1;
61912   if (!jarg2) {
61913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61914     return 0;
61915   }
61916   std::string arg2_str(jarg2);
61917   arg2 = &arg2_str;
61918   {
61919     try {
61920       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61921     } catch (std::out_of_range& e) {
61922       {
61923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61924       };
61925     } catch (std::exception& e) {
61926       {
61927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61928       };
61929     } catch (Dali::DaliException e) {
61930       {
61931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61932       };
61933     } catch (...) {
61934       {
61935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61936       };
61937     }
61938   }
61939
61940   jresult = (void *)result;
61941
61942   //argout typemap for const std::string&
61943
61944   return jresult;
61945 }
61946
61947
61948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61949   void * jresult ;
61950   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61951   std::string *arg2 = 0 ;
61952   Dali::Animation result;
61953
61954   arg1 = (Dali::Toolkit::Builder *)jarg1;
61955   if (!jarg2) {
61956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61957     return 0;
61958   }
61959   std::string arg2_str(jarg2);
61960   arg2 = &arg2_str;
61961   {
61962     try {
61963       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61964     } catch (std::out_of_range& e) {
61965       {
61966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61967       };
61968     } catch (std::exception& e) {
61969       {
61970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61971       };
61972     } catch (Dali::DaliException e) {
61973       {
61974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61975       };
61976     } catch (...) {
61977       {
61978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61979       };
61980     }
61981   }
61982
61983   jresult = new Dali::Animation((const Dali::Animation &)result);
61984
61985   //argout typemap for const std::string&
61986
61987   return jresult;
61988 }
61989
61990
61991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61992   void * jresult ;
61993   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61994   std::string *arg2 = 0 ;
61995   Dali::Property::Map *arg3 = 0 ;
61996   Dali::Animation result;
61997
61998   arg1 = (Dali::Toolkit::Builder *)jarg1;
61999   if (!jarg2) {
62000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62001     return 0;
62002   }
62003   std::string arg2_str(jarg2);
62004   arg2 = &arg2_str;
62005   arg3 = (Dali::Property::Map *)jarg3;
62006   if (!arg3) {
62007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62008     return 0;
62009   }
62010   {
62011     try {
62012       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62013     } catch (std::out_of_range& e) {
62014       {
62015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62016       };
62017     } catch (std::exception& e) {
62018       {
62019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62020       };
62021     } catch (Dali::DaliException e) {
62022       {
62023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62024       };
62025     } catch (...) {
62026       {
62027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62028       };
62029     }
62030   }
62031
62032   jresult = new Dali::Animation((const Dali::Animation &)result);
62033
62034   //argout typemap for const std::string&
62035
62036   return jresult;
62037 }
62038
62039
62040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62041   void * jresult ;
62042   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62043   std::string *arg2 = 0 ;
62044   Dali::Actor arg3 ;
62045   Dali::Actor *argp3 ;
62046   Dali::Animation result;
62047
62048   arg1 = (Dali::Toolkit::Builder *)jarg1;
62049   if (!jarg2) {
62050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62051     return 0;
62052   }
62053   std::string arg2_str(jarg2);
62054   arg2 = &arg2_str;
62055   argp3 = (Dali::Actor *)jarg3;
62056   if (!argp3) {
62057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62058     return 0;
62059   }
62060   arg3 = *argp3;
62061   {
62062     try {
62063       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
62064     } catch (std::out_of_range& e) {
62065       {
62066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62067       };
62068     } catch (std::exception& e) {
62069       {
62070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62071       };
62072     } catch (Dali::DaliException e) {
62073       {
62074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62075       };
62076     } catch (...) {
62077       {
62078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62079       };
62080     }
62081   }
62082
62083   jresult = new Dali::Animation((const Dali::Animation &)result);
62084
62085   //argout typemap for const std::string&
62086
62087   return jresult;
62088 }
62089
62090
62091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
62092   void * jresult ;
62093   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62094   std::string *arg2 = 0 ;
62095   Dali::Property::Map *arg3 = 0 ;
62096   Dali::Actor arg4 ;
62097   Dali::Actor *argp4 ;
62098   Dali::Animation result;
62099
62100   arg1 = (Dali::Toolkit::Builder *)jarg1;
62101   if (!jarg2) {
62102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62103     return 0;
62104   }
62105   std::string arg2_str(jarg2);
62106   arg2 = &arg2_str;
62107   arg3 = (Dali::Property::Map *)jarg3;
62108   if (!arg3) {
62109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62110     return 0;
62111   }
62112   argp4 = (Dali::Actor *)jarg4;
62113   if (!argp4) {
62114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62115     return 0;
62116   }
62117   arg4 = *argp4;
62118   {
62119     try {
62120       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
62121     } catch (std::out_of_range& e) {
62122       {
62123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62124       };
62125     } catch (std::exception& e) {
62126       {
62127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62128       };
62129     } catch (Dali::DaliException e) {
62130       {
62131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62132       };
62133     } catch (...) {
62134       {
62135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62136       };
62137     }
62138   }
62139
62140   jresult = new Dali::Animation((const Dali::Animation &)result);
62141
62142   //argout typemap for const std::string&
62143
62144   return jresult;
62145 }
62146
62147
62148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
62149   void * jresult ;
62150   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62151   std::string *arg2 = 0 ;
62152   Dali::BaseHandle result;
62153
62154   arg1 = (Dali::Toolkit::Builder *)jarg1;
62155   if (!jarg2) {
62156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62157     return 0;
62158   }
62159   std::string arg2_str(jarg2);
62160   arg2 = &arg2_str;
62161   {
62162     try {
62163       result = (arg1)->Create((std::string const &)*arg2);
62164     } catch (std::out_of_range& e) {
62165       {
62166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62167       };
62168     } catch (std::exception& e) {
62169       {
62170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62171       };
62172     } catch (Dali::DaliException e) {
62173       {
62174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62175       };
62176     } catch (...) {
62177       {
62178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62179       };
62180     }
62181   }
62182
62183   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62184
62185   //argout typemap for const std::string&
62186
62187   return jresult;
62188 }
62189
62190
62191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62192   void * jresult ;
62193   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62194   std::string *arg2 = 0 ;
62195   Dali::Property::Map *arg3 = 0 ;
62196   Dali::BaseHandle result;
62197
62198   arg1 = (Dali::Toolkit::Builder *)jarg1;
62199   if (!jarg2) {
62200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62201     return 0;
62202   }
62203   std::string arg2_str(jarg2);
62204   arg2 = &arg2_str;
62205   arg3 = (Dali::Property::Map *)jarg3;
62206   if (!arg3) {
62207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62208     return 0;
62209   }
62210   {
62211     try {
62212       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62213     } catch (std::out_of_range& e) {
62214       {
62215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62216       };
62217     } catch (std::exception& e) {
62218       {
62219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62220       };
62221     } catch (Dali::DaliException e) {
62222       {
62223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62224       };
62225     } catch (...) {
62226       {
62227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62228       };
62229     }
62230   }
62231
62232   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62233
62234   //argout typemap for const std::string&
62235
62236   return jresult;
62237 }
62238
62239
62240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62241   void * jresult ;
62242   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62243   std::string *arg2 = 0 ;
62244   Dali::BaseHandle result;
62245
62246   arg1 = (Dali::Toolkit::Builder *)jarg1;
62247   if (!jarg2) {
62248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62249     return 0;
62250   }
62251   std::string arg2_str(jarg2);
62252   arg2 = &arg2_str;
62253   {
62254     try {
62255       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62256     } catch (std::out_of_range& e) {
62257       {
62258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62259       };
62260     } catch (std::exception& e) {
62261       {
62262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62263       };
62264     } catch (Dali::DaliException e) {
62265       {
62266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62267       };
62268     } catch (...) {
62269       {
62270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62271       };
62272     }
62273   }
62274
62275   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62276
62277   //argout typemap for const std::string&
62278
62279   return jresult;
62280 }
62281
62282
62283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62284   unsigned int jresult ;
62285   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62286   std::string *arg2 = 0 ;
62287   Dali::Handle *arg3 = 0 ;
62288   bool result;
62289
62290   arg1 = (Dali::Toolkit::Builder *)jarg1;
62291   if (!jarg2) {
62292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62293     return 0;
62294   }
62295   std::string arg2_str(jarg2);
62296   arg2 = &arg2_str;
62297   arg3 = (Dali::Handle *)jarg3;
62298   if (!arg3) {
62299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62300     return 0;
62301   }
62302   {
62303     try {
62304       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62305     } catch (std::out_of_range& e) {
62306       {
62307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62308       };
62309     } catch (std::exception& e) {
62310       {
62311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62312       };
62313     } catch (Dali::DaliException e) {
62314       {
62315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62316       };
62317     } catch (...) {
62318       {
62319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62320       };
62321     }
62322   }
62323
62324   jresult = result;
62325
62326   //argout typemap for const std::string&
62327
62328   return jresult;
62329 }
62330
62331
62332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62333   unsigned int jresult ;
62334   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62335   Dali::Handle *arg2 = 0 ;
62336   std::string *arg3 = 0 ;
62337   bool result;
62338
62339   arg1 = (Dali::Toolkit::Builder *)jarg1;
62340   arg2 = (Dali::Handle *)jarg2;
62341   if (!arg2) {
62342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62343     return 0;
62344   }
62345   if (!jarg3) {
62346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62347     return 0;
62348   }
62349   std::string arg3_str(jarg3);
62350   arg3 = &arg3_str;
62351   {
62352     try {
62353       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62354     } catch (std::out_of_range& e) {
62355       {
62356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62357       };
62358     } catch (std::exception& e) {
62359       {
62360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62361       };
62362     } catch (Dali::DaliException e) {
62363       {
62364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62365       };
62366     } catch (...) {
62367       {
62368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62369       };
62370     }
62371   }
62372
62373   jresult = result;
62374
62375   //argout typemap for const std::string&
62376
62377   return jresult;
62378 }
62379
62380
62381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62382   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62383   Dali::Actor arg2 ;
62384   Dali::Actor *argp2 ;
62385
62386   arg1 = (Dali::Toolkit::Builder *)jarg1;
62387   argp2 = (Dali::Actor *)jarg2;
62388   if (!argp2) {
62389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62390     return ;
62391   }
62392   arg2 = *argp2;
62393   {
62394     try {
62395       (arg1)->AddActors(arg2);
62396     } catch (std::out_of_range& e) {
62397       {
62398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62399       };
62400     } catch (std::exception& e) {
62401       {
62402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62403       };
62404     } catch (Dali::DaliException e) {
62405       {
62406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62407       };
62408     } catch (...) {
62409       {
62410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62411       };
62412     }
62413   }
62414
62415 }
62416
62417
62418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62419   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62420   std::string *arg2 = 0 ;
62421   Dali::Actor arg3 ;
62422   Dali::Actor *argp3 ;
62423
62424   arg1 = (Dali::Toolkit::Builder *)jarg1;
62425   if (!jarg2) {
62426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62427     return ;
62428   }
62429   std::string arg2_str(jarg2);
62430   arg2 = &arg2_str;
62431   argp3 = (Dali::Actor *)jarg3;
62432   if (!argp3) {
62433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62434     return ;
62435   }
62436   arg3 = *argp3;
62437   {
62438     try {
62439       (arg1)->AddActors((std::string const &)*arg2,arg3);
62440     } catch (std::out_of_range& e) {
62441       {
62442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62443       };
62444     } catch (std::exception& e) {
62445       {
62446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62447       };
62448     } catch (Dali::DaliException e) {
62449       {
62450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62451       };
62452     } catch (...) {
62453       {
62454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62455       };
62456     }
62457   }
62458
62459
62460   //argout typemap for const std::string&
62461
62462 }
62463
62464
62465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62466   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62467   std::string *arg2 = 0 ;
62468
62469   arg1 = (Dali::Toolkit::Builder *)jarg1;
62470   if (!jarg2) {
62471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62472     return ;
62473   }
62474   std::string arg2_str(jarg2);
62475   arg2 = &arg2_str;
62476   {
62477     try {
62478       (arg1)->CreateRenderTask((std::string const &)*arg2);
62479     } catch (std::out_of_range& e) {
62480       {
62481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62482       };
62483     } catch (std::exception& e) {
62484       {
62485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62486       };
62487     } catch (Dali::DaliException e) {
62488       {
62489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62490       };
62491     } catch (...) {
62492       {
62493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62494       };
62495     }
62496   }
62497
62498
62499   //argout typemap for const std::string&
62500
62501 }
62502
62503
62504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62505   void * jresult ;
62506   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62507   std::string *arg2 = 0 ;
62508   Dali::FrameBufferImage result;
62509
62510   arg1 = (Dali::Toolkit::Builder *)jarg1;
62511   if (!jarg2) {
62512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62513     return 0;
62514   }
62515   std::string arg2_str(jarg2);
62516   arg2 = &arg2_str;
62517   {
62518     try {
62519       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62520     } catch (std::out_of_range& e) {
62521       {
62522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62523       };
62524     } catch (std::exception& e) {
62525       {
62526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62527       };
62528     } catch (Dali::DaliException e) {
62529       {
62530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62531       };
62532     } catch (...) {
62533       {
62534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62535       };
62536     }
62537   }
62538
62539   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62540
62541   //argout typemap for const std::string&
62542
62543   return jresult;
62544 }
62545
62546
62547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62548   void * jresult ;
62549   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62550   std::string *arg2 = 0 ;
62551   Dali::Path result;
62552
62553   arg1 = (Dali::Toolkit::Builder *)jarg1;
62554   if (!jarg2) {
62555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62556     return 0;
62557   }
62558   std::string arg2_str(jarg2);
62559   arg2 = &arg2_str;
62560   {
62561     try {
62562       result = (arg1)->GetPath((std::string const &)*arg2);
62563     } catch (std::out_of_range& e) {
62564       {
62565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62566       };
62567     } catch (std::exception& e) {
62568       {
62569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62570       };
62571     } catch (Dali::DaliException e) {
62572       {
62573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62574       };
62575     } catch (...) {
62576       {
62577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62578       };
62579     }
62580   }
62581
62582   jresult = new Dali::Path((const Dali::Path &)result);
62583
62584   //argout typemap for const std::string&
62585
62586   return jresult;
62587 }
62588
62589
62590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62591   void * jresult ;
62592   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62593   std::string *arg2 = 0 ;
62594   Dali::PathConstrainer result;
62595
62596   arg1 = (Dali::Toolkit::Builder *)jarg1;
62597   if (!jarg2) {
62598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62599     return 0;
62600   }
62601   std::string arg2_str(jarg2);
62602   arg2 = &arg2_str;
62603   {
62604     try {
62605       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62606     } catch (std::out_of_range& e) {
62607       {
62608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62609       };
62610     } catch (std::exception& e) {
62611       {
62612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62613       };
62614     } catch (Dali::DaliException e) {
62615       {
62616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62617       };
62618     } catch (...) {
62619       {
62620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62621       };
62622     }
62623   }
62624
62625   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62626
62627   //argout typemap for const std::string&
62628
62629   return jresult;
62630 }
62631
62632
62633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62634   void * jresult ;
62635   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62636   std::string *arg2 = 0 ;
62637   Dali::LinearConstrainer result;
62638
62639   arg1 = (Dali::Toolkit::Builder *)jarg1;
62640   if (!jarg2) {
62641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62642     return 0;
62643   }
62644   std::string arg2_str(jarg2);
62645   arg2 = &arg2_str;
62646   {
62647     try {
62648       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62649     } catch (std::out_of_range& e) {
62650       {
62651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62652       };
62653     } catch (std::exception& e) {
62654       {
62655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62656       };
62657     } catch (Dali::DaliException e) {
62658       {
62659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62660       };
62661     } catch (...) {
62662       {
62663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62664       };
62665     }
62666   }
62667
62668   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62669
62670   //argout typemap for const std::string&
62671
62672   return jresult;
62673 }
62674
62675
62676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62677   void * jresult ;
62678   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62679   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62680
62681   arg1 = (Dali::Toolkit::Builder *)jarg1;
62682   {
62683     try {
62684       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62685     } catch (std::out_of_range& e) {
62686       {
62687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62688       };
62689     } catch (std::exception& e) {
62690       {
62691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62692       };
62693     } catch (Dali::DaliException e) {
62694       {
62695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62696       };
62697     } catch (...) {
62698       {
62699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62700       };
62701     }
62702   }
62703
62704   jresult = (void *)result;
62705   return jresult;
62706 }
62707
62708
62709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62710   void * jresult ;
62711   Dali::Toolkit::TransitionData *result = 0 ;
62712
62713   {
62714     try {
62715       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62716     } catch (std::out_of_range& e) {
62717       {
62718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62719       };
62720     } catch (std::exception& e) {
62721       {
62722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62723       };
62724     } catch (Dali::DaliException e) {
62725       {
62726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62727       };
62728     } catch (...) {
62729       {
62730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62731       };
62732     }
62733   }
62734
62735   jresult = (void *)result;
62736   return jresult;
62737 }
62738
62739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62740   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62741
62742   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62743   {
62744     try {
62745       delete arg1;
62746     } catch (std::out_of_range& e) {
62747       {
62748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62749       };
62750     } catch (std::exception& e) {
62751       {
62752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62753       };
62754     } catch (Dali::DaliException e) {
62755       {
62756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62757       };
62758     } catch (...) {
62759       {
62760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62761       };
62762     }
62763   }
62764
62765 }
62766
62767
62768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62769   void * jresult ;
62770   Dali::Property::Map *arg1 = 0 ;
62771   Dali::Toolkit::TransitionData result;
62772
62773   arg1 = (Dali::Property::Map *)jarg1;
62774   if (!arg1) {
62775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62776     return 0;
62777   }
62778   {
62779     try {
62780       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62781     } catch (std::out_of_range& e) {
62782       {
62783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62784       };
62785     } catch (std::exception& e) {
62786       {
62787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62788       };
62789     } catch (Dali::DaliException e) {
62790       {
62791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62792       };
62793     } catch (...) {
62794       {
62795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62796       };
62797     }
62798   }
62799
62800   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62801   return jresult;
62802 }
62803
62804
62805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62806   void * jresult ;
62807   Dali::Property::Array *arg1 = 0 ;
62808   Dali::Toolkit::TransitionData result;
62809
62810   arg1 = (Dali::Property::Array *)jarg1;
62811   if (!arg1) {
62812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62813     return 0;
62814   }
62815   {
62816     try {
62817       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62818     } catch (std::out_of_range& e) {
62819       {
62820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62821       };
62822     } catch (std::exception& e) {
62823       {
62824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62825       };
62826     } catch (Dali::DaliException e) {
62827       {
62828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62829       };
62830     } catch (...) {
62831       {
62832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62833       };
62834     }
62835   }
62836
62837   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62838   return jresult;
62839 }
62840
62841
62842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62843   void * jresult ;
62844   Dali::BaseHandle arg1 ;
62845   Dali::BaseHandle *argp1 ;
62846   Dali::Toolkit::TransitionData result;
62847
62848   argp1 = (Dali::BaseHandle *)jarg1;
62849   if (!argp1) {
62850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62851     return 0;
62852   }
62853   arg1 = *argp1;
62854   {
62855     try {
62856       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62857     } catch (std::out_of_range& e) {
62858       {
62859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62860       };
62861     } catch (std::exception& e) {
62862       {
62863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62864       };
62865     } catch (Dali::DaliException e) {
62866       {
62867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62868       };
62869     } catch (...) {
62870       {
62871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62872       };
62873     }
62874   }
62875
62876   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62877   return jresult;
62878 }
62879
62880
62881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62882   void * jresult ;
62883   Dali::Toolkit::TransitionData *arg1 = 0 ;
62884   Dali::Toolkit::TransitionData *result = 0 ;
62885
62886   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62887   if (!arg1) {
62888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62889     return 0;
62890   }
62891   {
62892     try {
62893       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62894     } catch (std::out_of_range& e) {
62895       {
62896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62897       };
62898     } catch (std::exception& e) {
62899       {
62900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62901       };
62902     } catch (Dali::DaliException e) {
62903       {
62904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62905       };
62906     } catch (...) {
62907       {
62908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62909       };
62910     }
62911   }
62912
62913   jresult = (void *)result;
62914   return jresult;
62915 }
62916
62917
62918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62919   void * jresult ;
62920   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62921   Dali::Toolkit::TransitionData *arg2 = 0 ;
62922   Dali::Toolkit::TransitionData *result = 0 ;
62923
62924   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62925   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62926   if (!arg2) {
62927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62928     return 0;
62929   }
62930   {
62931     try {
62932       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62933     } catch (std::out_of_range& e) {
62934       {
62935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62936       };
62937     } catch (std::exception& e) {
62938       {
62939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62940       };
62941     } catch (Dali::DaliException e) {
62942       {
62943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62944       };
62945     } catch (...) {
62946       {
62947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62948       };
62949     }
62950   }
62951
62952   jresult = (void *)result;
62953   return jresult;
62954 }
62955
62956
62957 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62958   unsigned long jresult ;
62959   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62960   size_t result;
62961
62962   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62963   {
62964     try {
62965       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62966     } catch (std::out_of_range& e) {
62967       {
62968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62969       };
62970     } catch (std::exception& e) {
62971       {
62972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62973       };
62974     } catch (Dali::DaliException e) {
62975       {
62976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62977       };
62978     } catch (...) {
62979       {
62980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62981       };
62982     }
62983   }
62984
62985   jresult = (unsigned long)result;
62986   return jresult;
62987 }
62988
62989
62990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62991   void * jresult ;
62992   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62993   size_t arg2 ;
62994   Dali::Property::Map result;
62995
62996   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62997   arg2 = (size_t)jarg2;
62998   {
62999     try {
63000       result = (arg1)->GetAnimatorAt(arg2);
63001     } catch (std::out_of_range& e) {
63002       {
63003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63004       };
63005     } catch (std::exception& e) {
63006       {
63007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63008       };
63009     } catch (Dali::DaliException e) {
63010       {
63011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63012       };
63013     } catch (...) {
63014       {
63015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63016       };
63017     }
63018   }
63019
63020   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
63021   return jresult;
63022 }
63023
63024
63025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
63026   int jresult ;
63027   int result;
63028
63029   {
63030     try {
63031       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
63032     } catch (std::out_of_range& e) {
63033       {
63034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63035       };
63036     } catch (std::exception& e) {
63037       {
63038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63039       };
63040     } catch (Dali::DaliException e) {
63041       {
63042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63043       };
63044     } catch (...) {
63045       {
63046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63047       };
63048     }
63049   }
63050
63051   jresult = (int)result;
63052   return jresult;
63053 }
63054
63055
63056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
63057   int jresult ;
63058   int result;
63059
63060   {
63061     try {
63062       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
63063     } catch (std::out_of_range& e) {
63064       {
63065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63066       };
63067     } catch (std::exception& e) {
63068       {
63069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63070       };
63071     } catch (Dali::DaliException e) {
63072       {
63073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63074       };
63075     } catch (...) {
63076       {
63077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63078       };
63079     }
63080   }
63081
63082   jresult = (int)result;
63083   return jresult;
63084 }
63085
63086
63087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
63088   int jresult ;
63089   int result;
63090
63091   {
63092     try {
63093       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
63094     } catch (std::out_of_range& e) {
63095       {
63096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63097       };
63098     } catch (std::exception& e) {
63099       {
63100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63101       };
63102     } catch (Dali::DaliException e) {
63103       {
63104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63105       };
63106     } catch (...) {
63107       {
63108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63109       };
63110     }
63111   }
63112
63113   jresult = (int)result;
63114   return jresult;
63115 }
63116
63117
63118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
63119   int jresult ;
63120   int result;
63121
63122   {
63123     try {
63124       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
63125     } catch (std::out_of_range& e) {
63126       {
63127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63128       };
63129     } catch (std::exception& e) {
63130       {
63131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63132       };
63133     } catch (Dali::DaliException e) {
63134       {
63135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63136       };
63137     } catch (...) {
63138       {
63139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63140       };
63141     }
63142   }
63143
63144   jresult = (int)result;
63145   return jresult;
63146 }
63147
63148
63149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
63150   int jresult ;
63151   int result;
63152
63153   {
63154     try {
63155       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
63156     } catch (std::out_of_range& e) {
63157       {
63158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63159       };
63160     } catch (std::exception& e) {
63161       {
63162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63163       };
63164     } catch (Dali::DaliException e) {
63165       {
63166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63167       };
63168     } catch (...) {
63169       {
63170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63171       };
63172     }
63173   }
63174
63175   jresult = (int)result;
63176   return jresult;
63177 }
63178
63179
63180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63181   int jresult ;
63182   int result;
63183
63184   {
63185     try {
63186       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63187     } catch (std::out_of_range& e) {
63188       {
63189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63190       };
63191     } catch (std::exception& e) {
63192       {
63193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63194       };
63195     } catch (Dali::DaliException e) {
63196       {
63197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63198       };
63199     } catch (...) {
63200       {
63201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63202       };
63203     }
63204   }
63205
63206   jresult = (int)result;
63207   return jresult;
63208 }
63209
63210
63211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63212   int jresult ;
63213   int result;
63214
63215   {
63216     try {
63217       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63218     } catch (std::out_of_range& e) {
63219       {
63220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63221       };
63222     } catch (std::exception& e) {
63223       {
63224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63225       };
63226     } catch (Dali::DaliException e) {
63227       {
63228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63229       };
63230     } catch (...) {
63231       {
63232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63233       };
63234     }
63235   }
63236
63237   jresult = (int)result;
63238   return jresult;
63239 }
63240
63241
63242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63243   int jresult ;
63244   int result;
63245
63246   {
63247     try {
63248       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63249     } catch (std::out_of_range& e) {
63250       {
63251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63252       };
63253     } catch (std::exception& e) {
63254       {
63255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63256       };
63257     } catch (Dali::DaliException e) {
63258       {
63259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63260       };
63261     } catch (...) {
63262       {
63263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63264       };
63265     }
63266   }
63267
63268   jresult = (int)result;
63269   return jresult;
63270 }
63271
63272
63273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63274   int jresult ;
63275   int result;
63276
63277   {
63278     try {
63279       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63280     } catch (std::out_of_range& e) {
63281       {
63282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63283       };
63284     } catch (std::exception& e) {
63285       {
63286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63287       };
63288     } catch (Dali::DaliException e) {
63289       {
63290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63291       };
63292     } catch (...) {
63293       {
63294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63295       };
63296     }
63297   }
63298
63299   jresult = (int)result;
63300   return jresult;
63301 }
63302
63303
63304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63305   int jresult ;
63306   int result;
63307
63308   {
63309     try {
63310       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63311     } catch (std::out_of_range& e) {
63312       {
63313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63314       };
63315     } catch (std::exception& e) {
63316       {
63317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63318       };
63319     } catch (Dali::DaliException e) {
63320       {
63321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63322       };
63323     } catch (...) {
63324       {
63325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63326       };
63327     }
63328   }
63329
63330   jresult = (int)result;
63331   return jresult;
63332 }
63333
63334
63335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63336   int jresult ;
63337   int result;
63338
63339   {
63340     try {
63341       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63342     } catch (std::out_of_range& e) {
63343       {
63344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63345       };
63346     } catch (std::exception& e) {
63347       {
63348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63349       };
63350     } catch (Dali::DaliException e) {
63351       {
63352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63353       };
63354     } catch (...) {
63355       {
63356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63357       };
63358     }
63359   }
63360
63361   jresult = (int)result;
63362   return jresult;
63363 }
63364
63365
63366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63367   int jresult ;
63368   int result;
63369
63370   {
63371     try {
63372       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63373     } catch (std::out_of_range& e) {
63374       {
63375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63376       };
63377     } catch (std::exception& e) {
63378       {
63379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63380       };
63381     } catch (Dali::DaliException e) {
63382       {
63383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63384       };
63385     } catch (...) {
63386       {
63387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63388       };
63389     }
63390   }
63391
63392   jresult = (int)result;
63393   return jresult;
63394 }
63395
63396
63397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63398   int jresult ;
63399   int result;
63400
63401   {
63402     try {
63403       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63404     } catch (std::out_of_range& e) {
63405       {
63406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63407       };
63408     } catch (std::exception& e) {
63409       {
63410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63411       };
63412     } catch (Dali::DaliException e) {
63413       {
63414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63415       };
63416     } catch (...) {
63417       {
63418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63419       };
63420     }
63421   }
63422
63423   jresult = (int)result;
63424   return jresult;
63425 }
63426
63427
63428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63429   int jresult ;
63430   int result;
63431
63432   {
63433     try {
63434       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63435     } catch (std::out_of_range& e) {
63436       {
63437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63438       };
63439     } catch (std::exception& e) {
63440       {
63441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63442       };
63443     } catch (Dali::DaliException e) {
63444       {
63445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63446       };
63447     } catch (...) {
63448       {
63449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63450       };
63451     }
63452   }
63453
63454   jresult = (int)result;
63455   return jresult;
63456 }
63457
63458
63459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63460   void * jresult ;
63461   Dali::Toolkit::Control result;
63462
63463   {
63464     try {
63465       result = Dali::Toolkit::Internal::Control::New();
63466     } catch (std::out_of_range& e) {
63467       {
63468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63469       };
63470     } catch (std::exception& e) {
63471       {
63472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63473       };
63474     } catch (Dali::DaliException e) {
63475       {
63476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63477       };
63478     } catch (...) {
63479       {
63480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63481       };
63482     }
63483   }
63484
63485   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63486   return jresult;
63487 }
63488
63489
63490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63491   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63492   std::string *arg2 = 0 ;
63493
63494   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63495   if (!jarg2) {
63496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63497     return ;
63498   }
63499   std::string arg2_str(jarg2);
63500   arg2 = &arg2_str;
63501   {
63502     try {
63503       (arg1)->SetStyleName((std::string const &)*arg2);
63504     } catch (std::out_of_range& e) {
63505       {
63506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63507       };
63508     } catch (std::exception& e) {
63509       {
63510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63511       };
63512     } catch (Dali::DaliException e) {
63513       {
63514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63515       };
63516     } catch (...) {
63517       {
63518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63519       };
63520     }
63521   }
63522
63523
63524   //argout typemap for const std::string&
63525
63526 }
63527
63528
63529 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63530   char * jresult ;
63531   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63532   std::string *result = 0 ;
63533
63534   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63535   {
63536     try {
63537       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63538     } catch (std::out_of_range& e) {
63539       {
63540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63541       };
63542     } catch (std::exception& e) {
63543       {
63544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63545       };
63546     } catch (Dali::DaliException e) {
63547       {
63548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63549       };
63550     } catch (...) {
63551       {
63552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63553       };
63554     }
63555   }
63556
63557   jresult = SWIG_csharp_string_callback(result->c_str());
63558   return jresult;
63559 }
63560
63561
63562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63563   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63564   Dali::Vector4 *arg2 = 0 ;
63565
63566   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63567   arg2 = (Dali::Vector4 *)jarg2;
63568   if (!arg2) {
63569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63570     return ;
63571   }
63572   {
63573     try {
63574       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63575     } catch (std::out_of_range& e) {
63576       {
63577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63578       };
63579     } catch (std::exception& e) {
63580       {
63581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63582       };
63583     } catch (Dali::DaliException e) {
63584       {
63585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63586       };
63587     } catch (...) {
63588       {
63589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63590       };
63591     }
63592   }
63593
63594 }
63595
63596
63597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63598   void * jresult ;
63599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63600   Dali::Vector4 result;
63601
63602   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63603   {
63604     try {
63605       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63606     } catch (std::out_of_range& e) {
63607       {
63608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63609       };
63610     } catch (std::exception& e) {
63611       {
63612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63613       };
63614     } catch (Dali::DaliException e) {
63615       {
63616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63617       };
63618     } catch (...) {
63619       {
63620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63621       };
63622     }
63623   }
63624
63625   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63626   return jresult;
63627 }
63628
63629
63630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63631   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63632   Dali::Image arg2 ;
63633   Dali::Image *argp2 ;
63634
63635   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63636   argp2 = (Dali::Image *)jarg2;
63637   if (!argp2) {
63638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63639     return ;
63640   }
63641   arg2 = *argp2;
63642   {
63643     try {
63644       (arg1)->SetBackgroundImage(arg2);
63645     } catch (std::out_of_range& e) {
63646       {
63647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63648       };
63649     } catch (std::exception& e) {
63650       {
63651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63652       };
63653     } catch (Dali::DaliException e) {
63654       {
63655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63656       };
63657     } catch (...) {
63658       {
63659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63660       };
63661     }
63662   }
63663
63664 }
63665
63666
63667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63669   Dali::Property::Map *arg2 = 0 ;
63670
63671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63672   arg2 = (Dali::Property::Map *)jarg2;
63673   if (!arg2) {
63674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63675     return ;
63676   }
63677   {
63678     try {
63679       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63680     } catch (std::out_of_range& e) {
63681       {
63682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63683       };
63684     } catch (std::exception& e) {
63685       {
63686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63687       };
63688     } catch (Dali::DaliException e) {
63689       {
63690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63691       };
63692     } catch (...) {
63693       {
63694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63695       };
63696     }
63697   }
63698
63699 }
63700
63701
63702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63703   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63704
63705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63706   {
63707     try {
63708       (arg1)->ClearBackground();
63709     } catch (std::out_of_range& e) {
63710       {
63711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63712       };
63713     } catch (std::exception& e) {
63714       {
63715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63716       };
63717     } catch (Dali::DaliException e) {
63718       {
63719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63720       };
63721     } catch (...) {
63722       {
63723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63724       };
63725     }
63726   }
63727
63728 }
63729
63730
63731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63732   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63733   Dali::Gesture::Type arg2 ;
63734
63735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63736   arg2 = (Dali::Gesture::Type)jarg2;
63737   {
63738     try {
63739       (arg1)->EnableGestureDetection(arg2);
63740     } catch (std::out_of_range& e) {
63741       {
63742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63743       };
63744     } catch (std::exception& e) {
63745       {
63746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63747       };
63748     } catch (Dali::DaliException e) {
63749       {
63750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63751       };
63752     } catch (...) {
63753       {
63754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63755       };
63756     }
63757   }
63758
63759 }
63760
63761
63762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63763   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63764   Dali::Gesture::Type arg2 ;
63765
63766   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63767   arg2 = (Dali::Gesture::Type)jarg2;
63768   {
63769     try {
63770       (arg1)->DisableGestureDetection(arg2);
63771     } catch (std::out_of_range& e) {
63772       {
63773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63774       };
63775     } catch (std::exception& e) {
63776       {
63777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63778       };
63779     } catch (Dali::DaliException e) {
63780       {
63781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63782       };
63783     } catch (...) {
63784       {
63785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63786       };
63787     }
63788   }
63789
63790 }
63791
63792
63793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63794   void * jresult ;
63795   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63796   Dali::PinchGestureDetector result;
63797
63798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63799   {
63800     try {
63801       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63802     } catch (std::out_of_range& e) {
63803       {
63804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63805       };
63806     } catch (std::exception& e) {
63807       {
63808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63809       };
63810     } catch (Dali::DaliException e) {
63811       {
63812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63813       };
63814     } catch (...) {
63815       {
63816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63817       };
63818     }
63819   }
63820
63821   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63822   return jresult;
63823 }
63824
63825
63826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63827   void * jresult ;
63828   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63829   Dali::PanGestureDetector result;
63830
63831   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63832   {
63833     try {
63834       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63835     } catch (std::out_of_range& e) {
63836       {
63837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63838       };
63839     } catch (std::exception& e) {
63840       {
63841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63842       };
63843     } catch (Dali::DaliException e) {
63844       {
63845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63846       };
63847     } catch (...) {
63848       {
63849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63850       };
63851     }
63852   }
63853
63854   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63855   return jresult;
63856 }
63857
63858
63859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63860   void * jresult ;
63861   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63862   Dali::TapGestureDetector result;
63863
63864   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63865   {
63866     try {
63867       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63868     } catch (std::out_of_range& e) {
63869       {
63870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63871       };
63872     } catch (std::exception& e) {
63873       {
63874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63875       };
63876     } catch (Dali::DaliException e) {
63877       {
63878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63879       };
63880     } catch (...) {
63881       {
63882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63883       };
63884     }
63885   }
63886
63887   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63888   return jresult;
63889 }
63890
63891
63892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63893   void * jresult ;
63894   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63895   Dali::LongPressGestureDetector result;
63896
63897   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63898   {
63899     try {
63900       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63901     } catch (std::out_of_range& e) {
63902       {
63903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63904       };
63905     } catch (std::exception& e) {
63906       {
63907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63908       };
63909     } catch (Dali::DaliException e) {
63910       {
63911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63912       };
63913     } catch (...) {
63914       {
63915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63916       };
63917     }
63918   }
63919
63920   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63921   return jresult;
63922 }
63923
63924
63925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63927   bool arg2 ;
63928
63929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63930   arg2 = jarg2 ? true : false;
63931   {
63932     try {
63933       (arg1)->SetKeyboardNavigationSupport(arg2);
63934     } catch (std::out_of_range& e) {
63935       {
63936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63937       };
63938     } catch (std::exception& e) {
63939       {
63940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63941       };
63942     } catch (Dali::DaliException e) {
63943       {
63944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63945       };
63946     } catch (...) {
63947       {
63948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63949       };
63950     }
63951   }
63952
63953 }
63954
63955
63956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63957   unsigned int jresult ;
63958   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63959   bool result;
63960
63961   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63962   {
63963     try {
63964       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63965     } catch (std::out_of_range& e) {
63966       {
63967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63968       };
63969     } catch (std::exception& e) {
63970       {
63971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63972       };
63973     } catch (Dali::DaliException e) {
63974       {
63975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63976       };
63977     } catch (...) {
63978       {
63979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63980       };
63981     }
63982   }
63983
63984   jresult = result;
63985   return jresult;
63986 }
63987
63988
63989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63990   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63991
63992   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63993   {
63994     try {
63995       (arg1)->SetKeyInputFocus();
63996     } catch (std::out_of_range& e) {
63997       {
63998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63999       };
64000     } catch (std::exception& e) {
64001       {
64002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64003       };
64004     } catch (Dali::DaliException e) {
64005       {
64006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64007       };
64008     } catch (...) {
64009       {
64010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64011       };
64012     }
64013   }
64014
64015 }
64016
64017
64018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
64019   unsigned int jresult ;
64020   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64021   bool result;
64022
64023   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64024   {
64025     try {
64026       result = (bool)(arg1)->HasKeyInputFocus();
64027     } catch (std::out_of_range& e) {
64028       {
64029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64030       };
64031     } catch (std::exception& e) {
64032       {
64033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64034       };
64035     } catch (Dali::DaliException e) {
64036       {
64037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64038       };
64039     } catch (...) {
64040       {
64041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64042       };
64043     }
64044   }
64045
64046   jresult = result;
64047   return jresult;
64048 }
64049
64050
64051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
64052   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64053
64054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64055   {
64056     try {
64057       (arg1)->ClearKeyInputFocus();
64058     } catch (std::out_of_range& e) {
64059       {
64060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64061       };
64062     } catch (std::exception& e) {
64063       {
64064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64065       };
64066     } catch (Dali::DaliException e) {
64067       {
64068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64069       };
64070     } catch (...) {
64071       {
64072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64073       };
64074     }
64075   }
64076
64077 }
64078
64079
64080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
64081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64082   bool arg2 ;
64083
64084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64085   arg2 = jarg2 ? true : false;
64086   {
64087     try {
64088       (arg1)->SetAsKeyboardFocusGroup(arg2);
64089     } catch (std::out_of_range& e) {
64090       {
64091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64092       };
64093     } catch (std::exception& e) {
64094       {
64095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64096       };
64097     } catch (Dali::DaliException e) {
64098       {
64099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64100       };
64101     } catch (...) {
64102       {
64103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64104       };
64105     }
64106   }
64107
64108 }
64109
64110
64111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
64112   unsigned int jresult ;
64113   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64114   bool result;
64115
64116   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64117   {
64118     try {
64119       result = (bool)(arg1)->IsKeyboardFocusGroup();
64120     } catch (std::out_of_range& e) {
64121       {
64122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64123       };
64124     } catch (std::exception& e) {
64125       {
64126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64127       };
64128     } catch (Dali::DaliException e) {
64129       {
64130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64131       };
64132     } catch (...) {
64133       {
64134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64135       };
64136     }
64137   }
64138
64139   jresult = result;
64140   return jresult;
64141 }
64142
64143
64144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64145   void * jresult ;
64146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64147   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64148
64149   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64150   {
64151     try {
64152       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64153     } catch (std::out_of_range& e) {
64154       {
64155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64156       };
64157     } catch (std::exception& e) {
64158       {
64159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64160       };
64161     } catch (Dali::DaliException e) {
64162       {
64163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64164       };
64165     } catch (...) {
64166       {
64167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64168       };
64169     }
64170   }
64171
64172   jresult = (void *)result;
64173   return jresult;
64174 }
64175
64176
64177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64178   void * jresult ;
64179   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64180   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64181
64182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64183   {
64184     try {
64185       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64186     } catch (std::out_of_range& e) {
64187       {
64188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64189       };
64190     } catch (std::exception& e) {
64191       {
64192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64193       };
64194     } catch (Dali::DaliException e) {
64195       {
64196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64197       };
64198     } catch (...) {
64199       {
64200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64201       };
64202     }
64203   }
64204
64205   jresult = (void *)result;
64206   return jresult;
64207 }
64208
64209
64210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64211   void * jresult ;
64212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64213   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64214
64215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64216   {
64217     try {
64218       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64219     } catch (std::out_of_range& e) {
64220       {
64221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64222       };
64223     } catch (std::exception& e) {
64224       {
64225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64226       };
64227     } catch (Dali::DaliException e) {
64228       {
64229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64230       };
64231     } catch (...) {
64232       {
64233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64234       };
64235     }
64236   }
64237
64238   jresult = (void *)result;
64239   return jresult;
64240 }
64241
64242
64243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64244   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64245   int arg2 ;
64246   SwigDirector_ViewImpl *darg = 0;
64247
64248   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64249   arg2 = (int)jarg2;
64250   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64251   if(!darg) {
64252     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64253     return;
64254   }
64255   {
64256     try {
64257       if(darg) {
64258         (darg)->OnStageConnection(arg2);
64259       }
64260     } catch (std::out_of_range& e) {
64261       {
64262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64263       };
64264     } catch (std::exception& e) {
64265       {
64266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64267       };
64268     } catch (Dali::DaliException e) {
64269       {
64270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64271       };
64272     } catch (...) {
64273       {
64274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64275       };
64276     }
64277   }
64278
64279 }
64280
64281
64282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64284   int arg2 ;
64285   SwigDirector_ViewImpl *darg = 0;
64286
64287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64288   arg2 = (int)jarg2;
64289   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64290   if(!darg) {
64291     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64292     return;
64293   }
64294   {
64295     try {
64296       if(darg) {
64297         (darg)->OnStageConnectionSwigPublic(arg2);
64298       }
64299     } catch (std::out_of_range& e) {
64300       {
64301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64302       };
64303     } catch (std::exception& e) {
64304       {
64305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64306       };
64307     } catch (Dali::DaliException e) {
64308       {
64309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64310       };
64311     } catch (...) {
64312       {
64313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64314       };
64315     }
64316   }
64317
64318 }
64319
64320
64321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64323   SwigDirector_ViewImpl *darg = 0;
64324
64325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64326   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64327   if(!darg) {
64328     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64329     return;
64330   }
64331   {
64332     try {
64333       if(darg) {
64334         (darg)->OnStageDisconnection();
64335       }
64336     } catch (std::out_of_range& e) {
64337       {
64338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64339       };
64340     } catch (std::exception& e) {
64341       {
64342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64343       };
64344     } catch (Dali::DaliException e) {
64345       {
64346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64347       };
64348     } catch (...) {
64349       {
64350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64351       };
64352     }
64353   }
64354
64355 }
64356
64357
64358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64360   SwigDirector_ViewImpl *darg = 0;
64361
64362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64363   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64364   if(!darg) {
64365     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64366     return;
64367   }
64368   {
64369     try {
64370       if(darg) {
64371         (darg)->OnStageDisconnectionSwigPublic();
64372       }
64373     } catch (std::out_of_range& e) {
64374       {
64375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64376       };
64377     } catch (std::exception& e) {
64378       {
64379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64380       };
64381     } catch (Dali::DaliException e) {
64382       {
64383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64384       };
64385     } catch (...) {
64386       {
64387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64388       };
64389     }
64390   }
64391
64392 }
64393
64394
64395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64396   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64397   Dali::Actor *arg2 = 0 ;
64398   SwigDirector_ViewImpl *darg = 0;
64399
64400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64401   arg2 = (Dali::Actor *)jarg2;
64402   if (!arg2) {
64403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64404     return ;
64405   }
64406   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64407   if(!darg) {
64408     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64409     return;
64410   }
64411   {
64412     try {
64413       if(darg) {
64414         (darg)->OnChildAdd(*arg2);
64415       }
64416     } catch (std::out_of_range& e) {
64417       {
64418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64419       };
64420     } catch (std::exception& e) {
64421       {
64422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64423       };
64424     } catch (Dali::DaliException e) {
64425       {
64426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64427       };
64428     } catch (...) {
64429       {
64430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64431       };
64432     }
64433   }
64434
64435 }
64436
64437
64438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64439   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64440   Dali::Actor *arg2 = 0 ;
64441   SwigDirector_ViewImpl *darg = 0;
64442
64443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64444   arg2 = (Dali::Actor *)jarg2;
64445   if (!arg2) {
64446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64447     return ;
64448   }
64449   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64450   if(!darg) {
64451     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64452     return;
64453   }
64454   {
64455     try {
64456       if(darg) {
64457           (darg)->OnChildAddSwigPublic(*arg2);
64458       }
64459     } catch (std::out_of_range& e) {
64460       {
64461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64462       };
64463     } catch (std::exception& e) {
64464       {
64465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64466       };
64467     } catch (Dali::DaliException e) {
64468       {
64469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64470       };
64471     } catch (...) {
64472       {
64473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64474       };
64475     }
64476   }
64477
64478 }
64479
64480
64481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64482   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64483   Dali::Actor *arg2 = 0 ;
64484   SwigDirector_ViewImpl *darg = 0;
64485
64486   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64487   arg2 = (Dali::Actor *)jarg2;
64488   if (!arg2) {
64489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64490     return ;
64491   }
64492   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64493   if(!darg) {
64494     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64495     return;
64496   }
64497   {
64498     try {
64499       if(darg) {
64500         (darg)->OnChildRemove(*arg2);
64501       }
64502     } catch (std::out_of_range& e) {
64503       {
64504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64505       };
64506     } catch (std::exception& e) {
64507       {
64508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64509       };
64510     } catch (Dali::DaliException e) {
64511       {
64512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64513       };
64514     } catch (...) {
64515       {
64516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64517       };
64518     }
64519   }
64520
64521 }
64522
64523
64524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64525   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64526   Dali::Actor *arg2 = 0 ;
64527   SwigDirector_ViewImpl *darg = 0;
64528
64529   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64530   arg2 = (Dali::Actor *)jarg2;
64531   if (!arg2) {
64532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64533     return ;
64534   }
64535   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64536   if(!darg) {
64537     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64538     return;
64539   }
64540   {
64541     try {
64542       if(darg) {
64543         (darg)->OnChildRemoveSwigPublic(*arg2);
64544       }
64545     } catch (std::out_of_range& e) {
64546       {
64547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64548       };
64549     } catch (std::exception& e) {
64550       {
64551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64552       };
64553     } catch (Dali::DaliException e) {
64554       {
64555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64556       };
64557     } catch (...) {
64558       {
64559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64560       };
64561     }
64562   }
64563
64564 }
64565
64566
64567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64568   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64569   Dali::Property::Index arg2 ;
64570   Dali::Property::Value arg3 ;
64571   Dali::Property::Value *argp3 ;
64572   SwigDirector_ViewImpl *darg = 0;
64573
64574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64575   arg2 = (Dali::Property::Index)jarg2;
64576   argp3 = (Dali::Property::Value *)jarg3;
64577   if (!argp3) {
64578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64579     return ;
64580   }
64581   arg3 = *argp3;
64582   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64583   if (!darg) {
64584     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64585     return;
64586   }
64587   {
64588     try {
64589       (darg)->OnPropertySet(arg2,arg3);
64590     } catch (std::out_of_range& e) {
64591       {
64592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64593       };
64594     } catch (std::exception& e) {
64595       {
64596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64597       };
64598     } catch (Dali::DaliException e) {
64599       {
64600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64601       };
64602     } catch (...) {
64603       {
64604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64605       };
64606     }
64607   }
64608
64609 }
64610
64611
64612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64614   Dali::Property::Index arg2 ;
64615   Dali::Property::Value arg3 ;
64616   Dali::Property::Value *argp3 ;
64617   SwigDirector_ViewImpl *darg = 0;
64618
64619   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64620   arg2 = (Dali::Property::Index)jarg2;
64621   argp3 = (Dali::Property::Value *)jarg3;
64622   if (!argp3) {
64623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64624     return ;
64625   }
64626   arg3 = *argp3;
64627   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64628   if (!darg) {
64629     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64630     return;
64631   }
64632   {
64633     try {
64634       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64635     } catch (std::out_of_range& e) {
64636       {
64637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64638       };
64639     } catch (std::exception& e) {
64640       {
64641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64642       };
64643     } catch (Dali::DaliException e) {
64644       {
64645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64646       };
64647     } catch (...) {
64648       {
64649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64650       };
64651     }
64652   }
64653
64654 }
64655
64656
64657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64658   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64659   Dali::Vector3 *arg2 = 0 ;
64660   SwigDirector_ViewImpl *darg = 0;
64661
64662   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64663   arg2 = (Dali::Vector3 *)jarg2;
64664   if (!arg2) {
64665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64666     return ;
64667   }
64668   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64669   if (!darg) {
64670     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64671     return;
64672   }
64673   {
64674     try {
64675       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64676     } catch (std::out_of_range& e) {
64677       {
64678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64679       };
64680     } catch (std::exception& e) {
64681       {
64682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64683       };
64684     } catch (Dali::DaliException e) {
64685       {
64686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64687       };
64688     } catch (...) {
64689       {
64690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64691       };
64692     }
64693   }
64694
64695 }
64696
64697
64698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64699   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64700   Dali::Vector3 *arg2 = 0 ;
64701   SwigDirector_ViewImpl *darg = 0;
64702
64703   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64704   arg2 = (Dali::Vector3 *)jarg2;
64705   if (!arg2) {
64706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64707     return ;
64708   }
64709   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64710   if (!darg) {
64711     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64712     return;
64713   }
64714   {
64715     try {
64716       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64717     } catch (std::out_of_range& e) {
64718       {
64719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64720       };
64721     } catch (std::exception& e) {
64722       {
64723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64724       };
64725     } catch (Dali::DaliException e) {
64726       {
64727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64728       };
64729     } catch (...) {
64730       {
64731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64732       };
64733     }
64734   }
64735
64736 }
64737
64738
64739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64740   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64741   Dali::Animation *arg2 = 0 ;
64742   Dali::Vector3 *arg3 = 0 ;
64743   SwigDirector_ViewImpl *darg = 0;
64744
64745   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64746   arg2 = (Dali::Animation *)jarg2;
64747   if (!arg2) {
64748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64749     return ;
64750   }
64751   arg3 = (Dali::Vector3 *)jarg3;
64752   if (!arg3) {
64753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64754     return ;
64755   }
64756   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64757   if (!darg) {
64758     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64759     return;
64760   }
64761   {
64762     try {
64763       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64764     } catch (std::out_of_range& e) {
64765       {
64766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64767       };
64768     } catch (std::exception& e) {
64769       {
64770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64771       };
64772     } catch (Dali::DaliException e) {
64773       {
64774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64775       };
64776     } catch (...) {
64777       {
64778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64779       };
64780     }
64781   }
64782
64783 }
64784
64785
64786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64787   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64788   Dali::Animation *arg2 = 0 ;
64789   Dali::Vector3 *arg3 = 0 ;
64790   SwigDirector_ViewImpl *darg = 0;
64791
64792   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64793   arg2 = (Dali::Animation *)jarg2;
64794   if (!arg2) {
64795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64796     return ;
64797   }
64798   arg3 = (Dali::Vector3 *)jarg3;
64799   if (!arg3) {
64800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64801     return ;
64802   }
64803   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64804   if (!darg) {
64805     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64806     return;
64807   }
64808   {
64809     try {
64810       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64811     } catch (std::out_of_range& e) {
64812       {
64813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64814       };
64815     } catch (std::exception& e) {
64816       {
64817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64818       };
64819     } catch (Dali::DaliException e) {
64820       {
64821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64822       };
64823     } catch (...) {
64824       {
64825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64826       };
64827     }
64828   }
64829
64830 }
64831
64832
64833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64834   unsigned int jresult ;
64835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64836   Dali::TouchEvent *arg2 = 0 ;
64837   SwigDirector_ViewImpl *darg = 0;
64838   bool result;
64839
64840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64841   arg2 = (Dali::TouchEvent *)jarg2;
64842   if (!arg2) {
64843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64844     return 0;
64845   }
64846   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64847   if (!darg) {
64848     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64849     return 0;
64850   }
64851   {
64852     try {
64853       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64854     } catch (std::out_of_range& e) {
64855       {
64856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64857       };
64858     } catch (std::exception& e) {
64859       {
64860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64861       };
64862     } catch (Dali::DaliException e) {
64863       {
64864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64865       };
64866     } catch (...) {
64867       {
64868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64869       };
64870     }
64871   }
64872
64873   jresult = result;
64874   return jresult;
64875 }
64876
64877
64878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64879   unsigned int jresult ;
64880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64881   Dali::TouchEvent *arg2 = 0 ;
64882   SwigDirector_ViewImpl *darg = 0;
64883   bool result;
64884
64885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64886   arg2 = (Dali::TouchEvent *)jarg2;
64887   if (!arg2) {
64888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64889     return 0;
64890   }
64891   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64892   if (!darg) {
64893     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64894     return 0;
64895   }
64896   {
64897     try {
64898       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64899     } catch (std::out_of_range& e) {
64900       {
64901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64902       };
64903     } catch (std::exception& e) {
64904       {
64905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64906       };
64907     } catch (Dali::DaliException e) {
64908       {
64909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64910       };
64911     } catch (...) {
64912       {
64913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64914       };
64915     }
64916   }
64917
64918   jresult = result;
64919   return jresult;
64920 }
64921
64922
64923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64924   unsigned int jresult ;
64925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64926   Dali::HoverEvent *arg2 = 0 ;
64927   SwigDirector_ViewImpl *darg = 0;
64928   bool result;
64929
64930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64931   arg2 = (Dali::HoverEvent *)jarg2;
64932   if (!arg2) {
64933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64934     return 0;
64935   }
64936   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64937   if (!darg) {
64938     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64939     return 0;
64940   }
64941   {
64942     try {
64943       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64944     } catch (std::out_of_range& e) {
64945       {
64946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64947       };
64948     } catch (std::exception& e) {
64949       {
64950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64951       };
64952     } catch (Dali::DaliException e) {
64953       {
64954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64955       };
64956     } catch (...) {
64957       {
64958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64959       };
64960     }
64961   }
64962
64963   jresult = result;
64964   return jresult;
64965 }
64966
64967
64968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64969   unsigned int jresult ;
64970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64971   Dali::HoverEvent *arg2 = 0 ;
64972   SwigDirector_ViewImpl *darg = 0;
64973   bool result;
64974
64975   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64976   arg2 = (Dali::HoverEvent *)jarg2;
64977   if (!arg2) {
64978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64979     return 0;
64980   }
64981   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64982   if (!darg) {
64983     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64984     return 0;
64985   }
64986   {
64987     try {
64988       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64989     } catch (std::out_of_range& e) {
64990       {
64991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64992       };
64993     } catch (std::exception& e) {
64994       {
64995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64996       };
64997     } catch (Dali::DaliException e) {
64998       {
64999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65000       };
65001     } catch (...) {
65002       {
65003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65004       };
65005     }
65006   }
65007
65008   jresult = result;
65009   return jresult;
65010 }
65011
65012
65013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
65014   unsigned int jresult ;
65015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65016   Dali::KeyEvent *arg2 = 0 ;
65017   SwigDirector_ViewImpl *darg = 0;
65018   bool result;
65019
65020   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65021   arg2 = (Dali::KeyEvent *)jarg2;
65022   if (!arg2) {
65023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65024     return 0;
65025   }
65026   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65027   if (!darg) {
65028     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65029     return 0;
65030   }
65031   {
65032     try {
65033       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
65034     } catch (std::out_of_range& e) {
65035       {
65036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65037       };
65038     } catch (std::exception& e) {
65039       {
65040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65041       };
65042     } catch (Dali::DaliException e) {
65043       {
65044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65045       };
65046     } catch (...) {
65047       {
65048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65049       };
65050     }
65051   }
65052
65053   jresult = result;
65054   return jresult;
65055 }
65056
65057
65058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65059   unsigned int jresult ;
65060   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65061   Dali::KeyEvent *arg2 = 0 ;
65062   SwigDirector_ViewImpl *darg = 0;
65063   bool result;
65064
65065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65066   arg2 = (Dali::KeyEvent *)jarg2;
65067   if (!arg2) {
65068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65069     return 0;
65070   }
65071   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65072   if (!darg) {
65073     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65074     return 0;
65075   }
65076   {
65077     try {
65078       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
65079     } catch (std::out_of_range& e) {
65080       {
65081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65082       };
65083     } catch (std::exception& e) {
65084       {
65085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65086       };
65087     } catch (Dali::DaliException e) {
65088       {
65089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65090       };
65091     } catch (...) {
65092       {
65093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65094       };
65095     }
65096   }
65097
65098   jresult = result;
65099   return jresult;
65100 }
65101
65102
65103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
65104   unsigned int jresult ;
65105   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65106   Dali::WheelEvent *arg2 = 0 ;
65107   SwigDirector_ViewImpl *darg = 0;
65108   bool result;
65109
65110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65111   arg2 = (Dali::WheelEvent *)jarg2;
65112   if (!arg2) {
65113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65114     return 0;
65115   }
65116   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65117   if (!darg) {
65118     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65119     return 0;
65120   }
65121   {
65122     try {
65123       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
65124     } catch (std::out_of_range& e) {
65125       {
65126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65127       };
65128     } catch (std::exception& e) {
65129       {
65130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65131       };
65132     } catch (Dali::DaliException e) {
65133       {
65134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65135       };
65136     } catch (...) {
65137       {
65138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65139       };
65140     }
65141   }
65142
65143   jresult = result;
65144   return jresult;
65145 }
65146
65147
65148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65149   unsigned int jresult ;
65150   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65151   Dali::WheelEvent *arg2 = 0 ;
65152   SwigDirector_ViewImpl *darg = 0;
65153   bool result;
65154
65155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65156   arg2 = (Dali::WheelEvent *)jarg2;
65157   if (!arg2) {
65158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65159     return 0;
65160   }
65161   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65162   if (!darg) {
65163     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65164     return 0;
65165   }
65166   {
65167     try {
65168       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
65169     } catch (std::out_of_range& e) {
65170       {
65171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65172       };
65173     } catch (std::exception& e) {
65174       {
65175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65176       };
65177     } catch (Dali::DaliException e) {
65178       {
65179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65180       };
65181     } catch (...) {
65182       {
65183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65184       };
65185     }
65186   }
65187
65188   jresult = result;
65189   return jresult;
65190 }
65191
65192
65193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65195   Dali::Vector2 *arg2 = 0 ;
65196   Dali::RelayoutContainer *arg3 = 0 ;
65197   SwigDirector_ViewImpl *darg = 0;
65198
65199   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65200   arg2 = (Dali::Vector2 *)jarg2;
65201   if (!arg2) {
65202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65203     return ;
65204   }
65205   arg3 = (Dali::RelayoutContainer *)jarg3;
65206   if (!arg3) {
65207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65208     return ;
65209   }
65210   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65211   if (!darg) {
65212     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65213     return;
65214   }
65215   {
65216     try {
65217       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65218     } catch (std::out_of_range& e) {
65219       {
65220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65221       };
65222     } catch (std::exception& e) {
65223       {
65224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65225       };
65226     } catch (Dali::DaliException e) {
65227       {
65228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65229       };
65230     } catch (...) {
65231       {
65232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65233       };
65234     }
65235   }
65236
65237 }
65238
65239
65240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65242   Dali::Vector2 *arg2 = 0 ;
65243   Dali::RelayoutContainer *arg3 = 0 ;
65244   SwigDirector_ViewImpl *darg = 0;
65245
65246   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65247   arg2 = (Dali::Vector2 *)jarg2;
65248   if (!arg2) {
65249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65250     return ;
65251   }
65252   arg3 = (Dali::RelayoutContainer *)jarg3;
65253   if (!arg3) {
65254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65255     return ;
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;
65261   }
65262   {
65263     try {
65264       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65265     } catch (std::out_of_range& e) {
65266       {
65267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65268       };
65269     } catch (std::exception& e) {
65270       {
65271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65272       };
65273     } catch (Dali::DaliException e) {
65274       {
65275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65276       };
65277     } catch (...) {
65278       {
65279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65280       };
65281     }
65282   }
65283
65284 }
65285
65286
65287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65289   Dali::ResizePolicy::Type arg2 ;
65290   Dali::Dimension::Type arg3 ;
65291   SwigDirector_ViewImpl *darg = 0;
65292
65293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65294   arg2 = (Dali::ResizePolicy::Type)jarg2;
65295   arg3 = (Dali::Dimension::Type)jarg3;
65296   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65297   if (!darg) {
65298     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65299     return;
65300   }
65301   {
65302     try {
65303       (darg)->OnSetResizePolicy(arg2,arg3);
65304     } catch (std::out_of_range& e) {
65305       {
65306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65307       };
65308     } catch (std::exception& e) {
65309       {
65310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65311       };
65312     } catch (Dali::DaliException e) {
65313       {
65314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65315       };
65316     } catch (...) {
65317       {
65318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65319       };
65320     }
65321   }
65322
65323 }
65324
65325
65326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65328   Dali::ResizePolicy::Type arg2 ;
65329   Dali::Dimension::Type arg3 ;
65330   SwigDirector_ViewImpl *darg = 0;
65331
65332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65333   arg2 = (Dali::ResizePolicy::Type)jarg2;
65334   arg3 = (Dali::Dimension::Type)jarg3;
65335   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65336   if (!darg) {
65337     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65338     return;
65339   }
65340   {
65341     try {
65342       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65343     } catch (std::out_of_range& e) {
65344       {
65345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65346       };
65347     } catch (std::exception& e) {
65348       {
65349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65350       };
65351     } catch (Dali::DaliException e) {
65352       {
65353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65354       };
65355     } catch (...) {
65356       {
65357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65358       };
65359     }
65360   }
65361
65362 }
65363
65364
65365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65366   void * jresult ;
65367   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65368   SwigDirector_ViewImpl *darg = 0;
65369   Dali::Vector3 result;
65370
65371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65372   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65373   if (!darg) {
65374     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65375     return 0;
65376   }
65377   {
65378     try {
65379       result = (darg)->GetNaturalSize();
65380     } catch (std::out_of_range& e) {
65381       {
65382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65383       };
65384     } catch (std::exception& e) {
65385       {
65386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65387       };
65388     } catch (Dali::DaliException e) {
65389       {
65390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65391       };
65392     } catch (...) {
65393       {
65394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65395       };
65396     }
65397   }
65398
65399   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65400   return jresult;
65401 }
65402
65403
65404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65405   void * jresult ;
65406   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65407   SwigDirector_ViewImpl *darg = 0;
65408   Dali::Vector3 result;
65409
65410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65411   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65412   if (!darg) {
65413     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65414     return 0;
65415   }
65416   {
65417     try {
65418       result = (darg)->GetNaturalSizeSwigPublic();
65419     } catch (std::out_of_range& e) {
65420       {
65421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65422       };
65423     } catch (std::exception& e) {
65424       {
65425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65426       };
65427     } catch (Dali::DaliException e) {
65428       {
65429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65430       };
65431     } catch (...) {
65432       {
65433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65434       };
65435     }
65436   }
65437
65438   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65439   return jresult;
65440 }
65441
65442
65443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65444   float jresult ;
65445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65446   Dali::Actor *arg2 = 0 ;
65447   Dali::Dimension::Type arg3 ;
65448   SwigDirector_ViewImpl *darg = 0;
65449   float result;
65450
65451   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65452   arg2 = (Dali::Actor *)jarg2;
65453   if (!arg2) {
65454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65455     return 0;
65456   }
65457   arg3 = (Dali::Dimension::Type)jarg3;
65458   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65459   if (!darg) {
65460     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65461     return 0;
65462   }
65463   {
65464     try {
65465       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65466     } catch (std::out_of_range& e) {
65467       {
65468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65469       };
65470     } catch (std::exception& e) {
65471       {
65472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65473       };
65474     } catch (Dali::DaliException e) {
65475       {
65476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65477       };
65478     } catch (...) {
65479       {
65480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65481       };
65482     }
65483   }
65484
65485   jresult = result;
65486   return jresult;
65487 }
65488
65489
65490 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65491   float jresult ;
65492   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65493   Dali::Actor *arg2 = 0 ;
65494   Dali::Dimension::Type arg3 ;
65495   SwigDirector_ViewImpl *darg = 0;
65496   float result;
65497
65498   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65499   arg2 = (Dali::Actor *)jarg2;
65500   if (!arg2) {
65501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65502     return 0;
65503   }
65504   arg3 = (Dali::Dimension::Type)jarg3;
65505   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65506   if (!darg) {
65507     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65508     return 0;
65509   }
65510   {
65511     try {
65512       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65513     } catch (std::out_of_range& e) {
65514       {
65515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65516       };
65517     } catch (std::exception& e) {
65518       {
65519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65520       };
65521     } catch (Dali::DaliException e) {
65522       {
65523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65524       };
65525     } catch (...) {
65526       {
65527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65528       };
65529     }
65530   }
65531
65532   jresult = result;
65533   return jresult;
65534 }
65535
65536
65537 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65538   float jresult ;
65539   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65540   float arg2 ;
65541   SwigDirector_ViewImpl *darg = 0;
65542   float result;
65543
65544   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65545   arg2 = (float)jarg2;
65546   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65547   if (!darg) {
65548     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65549     return 0;
65550   }
65551   {
65552     try {
65553       result = (float)(darg)->GetHeightForWidth(arg2);
65554     } catch (std::out_of_range& e) {
65555       {
65556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65557       };
65558     } catch (std::exception& e) {
65559       {
65560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65561       };
65562     } catch (Dali::DaliException e) {
65563       {
65564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65565       };
65566     } catch (...) {
65567       {
65568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65569       };
65570     }
65571   }
65572
65573   jresult = result;
65574   return jresult;
65575 }
65576
65577
65578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65579   float jresult ;
65580   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65581   float arg2 ;
65582   SwigDirector_ViewImpl *darg = 0;
65583   float result;
65584
65585   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65586   arg2 = (float)jarg2;
65587   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65588   if (!darg) {
65589     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65590     return 0;
65591   }
65592   {
65593     try {
65594       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65595     } catch (std::out_of_range& e) {
65596       {
65597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65598       };
65599     } catch (std::exception& e) {
65600       {
65601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65602       };
65603     } catch (Dali::DaliException e) {
65604       {
65605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65606       };
65607     } catch (...) {
65608       {
65609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65610       };
65611     }
65612   }
65613
65614   jresult = result;
65615   return jresult;
65616 }
65617
65618
65619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65620   float jresult ;
65621   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65622   float arg2 ;
65623   SwigDirector_ViewImpl *darg = 0;
65624   float result;
65625
65626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65627   arg2 = (float)jarg2;
65628   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65629   if (!darg) {
65630     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65631     return 0;
65632   }
65633   {
65634     try {
65635       result = (float)(darg)->GetWidthForHeight(arg2);
65636     } catch (std::out_of_range& e) {
65637       {
65638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65639       };
65640     } catch (std::exception& e) {
65641       {
65642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65643       };
65644     } catch (Dali::DaliException e) {
65645       {
65646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65647       };
65648     } catch (...) {
65649       {
65650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65651       };
65652     }
65653   }
65654
65655   jresult = result;
65656   return jresult;
65657 }
65658
65659
65660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65661   float jresult ;
65662   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65663   float arg2 ;
65664   SwigDirector_ViewImpl *darg = 0;
65665   float result;
65666
65667   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65668   arg2 = (float)jarg2;
65669   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65670   if (!darg) {
65671     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65672     return 0;
65673   }
65674   {
65675     try {
65676       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65677     } catch (std::out_of_range& e) {
65678       {
65679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65680       };
65681     } catch (std::exception& e) {
65682       {
65683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65684       };
65685     } catch (Dali::DaliException e) {
65686       {
65687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65688       };
65689     } catch (...) {
65690       {
65691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65692       };
65693     }
65694   }
65695
65696   jresult = result;
65697   return jresult;
65698 }
65699
65700
65701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65702   unsigned int jresult ;
65703   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65704   Dali::Dimension::Type arg2 ;
65705   SwigDirector_ViewImpl *darg = 0;
65706   bool result;
65707
65708   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65709   arg2 = (Dali::Dimension::Type)jarg2;
65710   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65711   if (!darg) {
65712     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65713     return 0;
65714   }
65715   {
65716     try {
65717       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65718     } catch (std::out_of_range& e) {
65719       {
65720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65721       };
65722     } catch (std::exception& e) {
65723       {
65724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65725       };
65726     } catch (Dali::DaliException e) {
65727       {
65728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65729       };
65730     } catch (...) {
65731       {
65732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65733       };
65734     }
65735   }
65736
65737   jresult = result;
65738   return jresult;
65739 }
65740
65741
65742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65743   unsigned int jresult ;
65744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65745   Dali::Dimension::Type arg2 ;
65746   SwigDirector_ViewImpl *darg = 0;
65747   bool result;
65748
65749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65750   arg2 = (Dali::Dimension::Type)jarg2;
65751   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65752   if (!darg) {
65753     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65754     return 0;
65755   }
65756   {
65757     try {
65758       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65759     } catch (std::out_of_range& e) {
65760       {
65761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65762       };
65763     } catch (std::exception& e) {
65764       {
65765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65766       };
65767     } catch (Dali::DaliException e) {
65768       {
65769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65770       };
65771     } catch (...) {
65772       {
65773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65774       };
65775     }
65776   }
65777
65778   jresult = result;
65779   return jresult;
65780 }
65781
65782
65783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65784   unsigned int jresult ;
65785   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65786   SwigDirector_ViewImpl *darg = 0;
65787   bool result;
65788
65789   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65790   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65791   if (!darg) {
65792     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65793     return 0;
65794   }
65795   {
65796     try {
65797       result = (bool)(darg)->RelayoutDependentOnChildren();
65798     } catch (std::out_of_range& e) {
65799       {
65800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65801       };
65802     } catch (std::exception& e) {
65803       {
65804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65805       };
65806     } catch (Dali::DaliException e) {
65807       {
65808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65809       };
65810     } catch (...) {
65811       {
65812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65813       };
65814     }
65815   }
65816
65817   jresult = result;
65818   return jresult;
65819 }
65820
65821
65822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65823   unsigned int jresult ;
65824   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65825   SwigDirector_ViewImpl *darg = 0;
65826   bool result;
65827
65828   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65829   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65830   if (!darg) {
65831     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65832     return 0;
65833   }
65834   {
65835     try {
65836       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65837     } catch (std::out_of_range& e) {
65838       {
65839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65840       };
65841     } catch (std::exception& e) {
65842       {
65843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65844       };
65845     } catch (Dali::DaliException e) {
65846       {
65847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65848       };
65849     } catch (...) {
65850       {
65851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65852       };
65853     }
65854   }
65855
65856   jresult = result;
65857   return jresult;
65858 }
65859
65860
65861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65863   Dali::Dimension::Type arg2 ;
65864   SwigDirector_ViewImpl *darg = 0;
65865
65866   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65867   arg2 = (Dali::Dimension::Type)jarg2;
65868   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65869   if (!darg) {
65870     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65871     return;
65872   }
65873   {
65874     try {
65875       (darg)->OnCalculateRelayoutSize(arg2);
65876     } catch (std::out_of_range& e) {
65877       {
65878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65879       };
65880     } catch (std::exception& e) {
65881       {
65882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65883       };
65884     } catch (Dali::DaliException e) {
65885       {
65886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65887       };
65888     } catch (...) {
65889       {
65890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65891       };
65892     }
65893   }
65894
65895 }
65896
65897
65898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65899   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65900   Dali::Dimension::Type arg2 ;
65901   SwigDirector_ViewImpl *darg = 0;
65902
65903   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65904   arg2 = (Dali::Dimension::Type)jarg2;
65905   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65906   if (!darg) {
65907     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65908     return;
65909   }
65910   {
65911     try {
65912       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65913     } catch (std::out_of_range& e) {
65914       {
65915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65916       };
65917     } catch (std::exception& e) {
65918       {
65919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65920       };
65921     } catch (Dali::DaliException e) {
65922       {
65923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65924       };
65925     } catch (...) {
65926       {
65927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65928       };
65929     }
65930   }
65931
65932 }
65933
65934
65935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65936   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65937   float arg2 ;
65938   Dali::Dimension::Type arg3 ;
65939   SwigDirector_ViewImpl *darg = 0;
65940
65941   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65942   arg2 = (float)jarg2;
65943   arg3 = (Dali::Dimension::Type)jarg3;
65944   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65945   if (!darg) {
65946     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65947     return;
65948   }
65949   {
65950     try {
65951       (darg)->OnLayoutNegotiated(arg2,arg3);
65952     } catch (std::out_of_range& e) {
65953       {
65954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65955       };
65956     } catch (std::exception& e) {
65957       {
65958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65959       };
65960     } catch (Dali::DaliException e) {
65961       {
65962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65963       };
65964     } catch (...) {
65965       {
65966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65967       };
65968     }
65969   }
65970
65971 }
65972
65973
65974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65976   float arg2 ;
65977   Dali::Dimension::Type arg3 ;
65978   SwigDirector_ViewImpl *darg = 0;
65979
65980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65981   arg2 = (float)jarg2;
65982   arg3 = (Dali::Dimension::Type)jarg3;
65983   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65984   if (!darg) {
65985     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65986     return;
65987   }
65988   {
65989     try {
65990       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65991     } catch (std::out_of_range& e) {
65992       {
65993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65994       };
65995     } catch (std::exception& e) {
65996       {
65997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65998       };
65999     } catch (Dali::DaliException e) {
66000       {
66001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66002       };
66003     } catch (...) {
66004       {
66005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66006       };
66007     }
66008   }
66009
66010 }
66011
66012
66013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
66014   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66015
66016   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66017   {
66018     try {
66019       (arg1)->OnInitialize();
66020     } catch (std::out_of_range& e) {
66021       {
66022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66023       };
66024     } catch (std::exception& e) {
66025       {
66026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66027       };
66028     } catch (Dali::DaliException e) {
66029       {
66030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66031       };
66032     } catch (...) {
66033       {
66034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66035       };
66036     }
66037   }
66038
66039 }
66040
66041
66042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
66043   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66044
66045   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66046   {
66047     try {
66048       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
66049     } catch (std::out_of_range& e) {
66050       {
66051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66052       };
66053     } catch (std::exception& e) {
66054       {
66055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66056       };
66057     } catch (Dali::DaliException e) {
66058       {
66059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66060       };
66061     } catch (...) {
66062       {
66063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66064       };
66065     }
66066   }
66067
66068 }
66069
66070
66071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
66072   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66073   Dali::Actor *arg2 = 0 ;
66074
66075   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66076   arg2 = (Dali::Actor *)jarg2;
66077   if (!arg2) {
66078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66079     return ;
66080   }
66081   {
66082     try {
66083       (arg1)->OnControlChildAdd(*arg2);
66084     } catch (std::out_of_range& e) {
66085       {
66086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66087       };
66088     } catch (std::exception& e) {
66089       {
66090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66091       };
66092     } catch (Dali::DaliException e) {
66093       {
66094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66095       };
66096     } catch (...) {
66097       {
66098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66099       };
66100     }
66101   }
66102
66103 }
66104
66105
66106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66107   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66108   Dali::Actor *arg2 = 0 ;
66109
66110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66111   arg2 = (Dali::Actor *)jarg2;
66112   if (!arg2) {
66113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66114     return ;
66115   }
66116   {
66117     try {
66118       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
66119     } catch (std::out_of_range& e) {
66120       {
66121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66122       };
66123     } catch (std::exception& e) {
66124       {
66125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66126       };
66127     } catch (Dali::DaliException e) {
66128       {
66129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66130       };
66131     } catch (...) {
66132       {
66133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66134       };
66135     }
66136   }
66137
66138 }
66139
66140
66141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
66142   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66143   Dali::Actor *arg2 = 0 ;
66144
66145   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66146   arg2 = (Dali::Actor *)jarg2;
66147   if (!arg2) {
66148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66149     return ;
66150   }
66151   {
66152     try {
66153       (arg1)->OnControlChildRemove(*arg2);
66154     } catch (std::out_of_range& e) {
66155       {
66156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66157       };
66158     } catch (std::exception& e) {
66159       {
66160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66161       };
66162     } catch (Dali::DaliException e) {
66163       {
66164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66165       };
66166     } catch (...) {
66167       {
66168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66169       };
66170     }
66171   }
66172
66173 }
66174
66175
66176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66178   Dali::Actor *arg2 = 0 ;
66179
66180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66181   arg2 = (Dali::Actor *)jarg2;
66182   if (!arg2) {
66183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66184     return ;
66185   }
66186   {
66187     try {
66188       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
66189     } catch (std::out_of_range& e) {
66190       {
66191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66192       };
66193     } catch (std::exception& e) {
66194       {
66195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66196       };
66197     } catch (Dali::DaliException e) {
66198       {
66199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66200       };
66201     } catch (...) {
66202       {
66203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66204       };
66205     }
66206   }
66207
66208 }
66209
66210
66211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
66212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66213   Dali::Toolkit::StyleManager arg2 ;
66214   Dali::StyleChange::Type arg3 ;
66215   Dali::Toolkit::StyleManager *argp2 ;
66216
66217   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66218   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66219   if (!argp2) {
66220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66221     return ;
66222   }
66223   arg2 = *argp2;
66224   arg3 = (Dali::StyleChange::Type)jarg3;
66225   {
66226     try {
66227       (arg1)->OnStyleChange(arg2,arg3);
66228     } catch (std::out_of_range& e) {
66229       {
66230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66231       };
66232     } catch (std::exception& e) {
66233       {
66234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66235       };
66236     } catch (Dali::DaliException e) {
66237       {
66238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66239       };
66240     } catch (...) {
66241       {
66242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66243       };
66244     }
66245   }
66246
66247 }
66248
66249
66250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
66251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66252   Dali::Toolkit::StyleManager arg2 ;
66253   Dali::StyleChange::Type arg3 ;
66254   Dali::Toolkit::StyleManager *argp2 ;
66255
66256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66257   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66258   if (!argp2) {
66259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66260     return ;
66261   }
66262   arg2 = *argp2;
66263   arg3 = (Dali::StyleChange::Type)jarg3;
66264   {
66265     try {
66266       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66267     } catch (std::out_of_range& e) {
66268       {
66269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66270       };
66271     } catch (std::exception& e) {
66272       {
66273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66274       };
66275     } catch (Dali::DaliException e) {
66276       {
66277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66278       };
66279     } catch (...) {
66280       {
66281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66282       };
66283     }
66284   }
66285
66286 }
66287
66288
66289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66290   unsigned int jresult ;
66291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66292   bool result;
66293
66294   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66295   {
66296     try {
66297       result = (bool)(arg1)->OnAccessibilityActivated();
66298     } catch (std::out_of_range& e) {
66299       {
66300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66301       };
66302     } catch (std::exception& e) {
66303       {
66304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66305       };
66306     } catch (Dali::DaliException e) {
66307       {
66308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66309       };
66310     } catch (...) {
66311       {
66312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66313       };
66314     }
66315   }
66316
66317   jresult = result;
66318   return jresult;
66319 }
66320
66321
66322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66323   unsigned int jresult ;
66324   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66325   bool result;
66326
66327   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66328   {
66329     try {
66330       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66331     } catch (std::out_of_range& e) {
66332       {
66333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66334       };
66335     } catch (std::exception& e) {
66336       {
66337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66338       };
66339     } catch (Dali::DaliException e) {
66340       {
66341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66342       };
66343     } catch (...) {
66344       {
66345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66346       };
66347     }
66348   }
66349
66350   jresult = result;
66351   return jresult;
66352 }
66353
66354
66355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66356   unsigned int jresult ;
66357   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66358   Dali::PanGesture arg2 ;
66359   Dali::PanGesture *argp2 ;
66360   bool result;
66361
66362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66363   argp2 = (Dali::PanGesture *)jarg2;
66364   if (!argp2) {
66365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66366     return 0;
66367   }
66368   arg2 = *argp2;
66369   {
66370     try {
66371       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66372     } catch (std::out_of_range& e) {
66373       {
66374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66375       };
66376     } catch (std::exception& e) {
66377       {
66378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66379       };
66380     } catch (Dali::DaliException e) {
66381       {
66382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66383       };
66384     } catch (...) {
66385       {
66386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66387       };
66388     }
66389   }
66390
66391   jresult = result;
66392   return jresult;
66393 }
66394
66395
66396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66397   unsigned int jresult ;
66398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66399   Dali::PanGesture arg2 ;
66400   Dali::PanGesture *argp2 ;
66401   bool result;
66402
66403   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66404   argp2 = (Dali::PanGesture *)jarg2;
66405   if (!argp2) {
66406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66407     return 0;
66408   }
66409   arg2 = *argp2;
66410   {
66411     try {
66412       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66413     } catch (std::out_of_range& e) {
66414       {
66415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66416       };
66417     } catch (std::exception& e) {
66418       {
66419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66420       };
66421     } catch (Dali::DaliException e) {
66422       {
66423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66424       };
66425     } catch (...) {
66426       {
66427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66428       };
66429     }
66430   }
66431
66432   jresult = result;
66433   return jresult;
66434 }
66435
66436
66437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66438   unsigned int jresult ;
66439   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66440   Dali::TouchEvent *arg2 = 0 ;
66441   bool result;
66442
66443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66444   arg2 = (Dali::TouchEvent *)jarg2;
66445   if (!arg2) {
66446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66447     return 0;
66448   }
66449   {
66450     try {
66451       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66452     } catch (std::out_of_range& e) {
66453       {
66454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66455       };
66456     } catch (std::exception& e) {
66457       {
66458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66459       };
66460     } catch (Dali::DaliException e) {
66461       {
66462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66463       };
66464     } catch (...) {
66465       {
66466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66467       };
66468     }
66469   }
66470
66471   jresult = result;
66472   return jresult;
66473 }
66474
66475
66476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66477   unsigned int jresult ;
66478   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66479   Dali::TouchEvent *arg2 = 0 ;
66480   bool result;
66481
66482   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66483   arg2 = (Dali::TouchEvent *)jarg2;
66484   if (!arg2) {
66485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66486     return 0;
66487   }
66488   {
66489     try {
66490       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66491     } catch (std::out_of_range& e) {
66492       {
66493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66494       };
66495     } catch (std::exception& e) {
66496       {
66497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66498       };
66499     } catch (Dali::DaliException e) {
66500       {
66501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66502       };
66503     } catch (...) {
66504       {
66505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66506       };
66507     }
66508   }
66509
66510   jresult = result;
66511   return jresult;
66512 }
66513
66514
66515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66516   unsigned int jresult ;
66517   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66518   bool arg2 ;
66519   bool result;
66520
66521   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66522   arg2 = jarg2 ? true : false;
66523   {
66524     try {
66525       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66526     } catch (std::out_of_range& e) {
66527       {
66528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66529       };
66530     } catch (std::exception& e) {
66531       {
66532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66533       };
66534     } catch (Dali::DaliException e) {
66535       {
66536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66537       };
66538     } catch (...) {
66539       {
66540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66541       };
66542     }
66543   }
66544
66545   jresult = result;
66546   return jresult;
66547 }
66548
66549
66550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66551   unsigned int jresult ;
66552   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66553   bool arg2 ;
66554   bool result;
66555
66556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66557   arg2 = jarg2 ? true : false;
66558   {
66559     try {
66560       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66561     } catch (std::out_of_range& e) {
66562       {
66563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66564       };
66565     } catch (std::exception& e) {
66566       {
66567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66568       };
66569     } catch (Dali::DaliException e) {
66570       {
66571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66572       };
66573     } catch (...) {
66574       {
66575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66576       };
66577     }
66578   }
66579
66580   jresult = result;
66581   return jresult;
66582 }
66583
66584
66585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66586   unsigned int jresult ;
66587   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66588   bool result;
66589
66590   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66591   {
66592     try {
66593       result = (bool)(arg1)->OnAccessibilityZoom();
66594     } catch (std::out_of_range& e) {
66595       {
66596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66597       };
66598     } catch (std::exception& e) {
66599       {
66600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66601       };
66602     } catch (Dali::DaliException e) {
66603       {
66604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66605       };
66606     } catch (...) {
66607       {
66608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66609       };
66610     }
66611   }
66612
66613   jresult = result;
66614   return jresult;
66615 }
66616
66617
66618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66619   unsigned int jresult ;
66620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66621   bool result;
66622
66623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66624   {
66625     try {
66626       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66627     } catch (std::out_of_range& e) {
66628       {
66629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66630       };
66631     } catch (std::exception& e) {
66632       {
66633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66634       };
66635     } catch (Dali::DaliException e) {
66636       {
66637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66638       };
66639     } catch (...) {
66640       {
66641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66642       };
66643     }
66644   }
66645
66646   jresult = result;
66647   return jresult;
66648 }
66649
66650
66651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66652   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66653
66654   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66655   {
66656     try {
66657       (arg1)->OnKeyInputFocusGained();
66658     } catch (std::out_of_range& e) {
66659       {
66660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66661       };
66662     } catch (std::exception& e) {
66663       {
66664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66665       };
66666     } catch (Dali::DaliException e) {
66667       {
66668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66669       };
66670     } catch (...) {
66671       {
66672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66673       };
66674     }
66675   }
66676
66677 }
66678
66679
66680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66682
66683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66684   {
66685     try {
66686       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66687     } catch (std::out_of_range& e) {
66688       {
66689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66690       };
66691     } catch (std::exception& e) {
66692       {
66693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66694       };
66695     } catch (Dali::DaliException e) {
66696       {
66697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66698       };
66699     } catch (...) {
66700       {
66701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66702       };
66703     }
66704   }
66705
66706 }
66707
66708
66709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66711
66712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66713   {
66714     try {
66715       (arg1)->OnKeyInputFocusLost();
66716     } catch (std::out_of_range& e) {
66717       {
66718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66719       };
66720     } catch (std::exception& e) {
66721       {
66722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66723       };
66724     } catch (Dali::DaliException e) {
66725       {
66726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66727       };
66728     } catch (...) {
66729       {
66730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66731       };
66732     }
66733   }
66734
66735 }
66736
66737
66738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66740
66741   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66742   {
66743     try {
66744       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66745     } catch (std::out_of_range& e) {
66746       {
66747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66748       };
66749     } catch (std::exception& e) {
66750       {
66751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66752       };
66753     } catch (Dali::DaliException e) {
66754       {
66755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66756       };
66757     } catch (...) {
66758       {
66759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66760       };
66761     }
66762   }
66763
66764 }
66765
66766
66767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66768   void * jresult ;
66769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66770   Dali::Actor arg2 ;
66771   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66772   bool arg4 ;
66773   Dali::Actor *argp2 ;
66774   Dali::Actor result;
66775
66776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66777   argp2 = (Dali::Actor *)jarg2;
66778   if (!argp2) {
66779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66780     return 0;
66781   }
66782   arg2 = *argp2;
66783   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66784   arg4 = jarg4 ? true : false;
66785   {
66786     try {
66787       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66788     } catch (std::out_of_range& e) {
66789       {
66790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66791       };
66792     } catch (std::exception& e) {
66793       {
66794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66795       };
66796     } catch (Dali::DaliException e) {
66797       {
66798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66799       };
66800     } catch (...) {
66801       {
66802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66803       };
66804     }
66805   }
66806
66807   jresult = new Dali::Actor((const Dali::Actor &)result);
66808   return jresult;
66809 }
66810
66811
66812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66813   void * jresult ;
66814   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66815   Dali::Actor arg2 ;
66816   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66817   bool arg4 ;
66818   Dali::Actor *argp2 ;
66819   Dali::Actor result;
66820
66821   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66822   argp2 = (Dali::Actor *)jarg2;
66823   if (!argp2) {
66824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66825     return 0;
66826   }
66827   arg2 = *argp2;
66828   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66829   arg4 = jarg4 ? true : false;
66830   {
66831     try {
66832       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66833     } catch (std::out_of_range& e) {
66834       {
66835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66836       };
66837     } catch (std::exception& e) {
66838       {
66839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66840       };
66841     } catch (Dali::DaliException e) {
66842       {
66843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66844       };
66845     } catch (...) {
66846       {
66847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66848       };
66849     }
66850   }
66851
66852   jresult = new Dali::Actor((const Dali::Actor &)result);
66853   return jresult;
66854 }
66855
66856
66857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66859   Dali::Actor arg2 ;
66860   Dali::Actor *argp2 ;
66861
66862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66863   argp2 = (Dali::Actor *)jarg2;
66864   if (!argp2) {
66865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66866     return ;
66867   }
66868   arg2 = *argp2;
66869   {
66870     try {
66871       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66872     } catch (std::out_of_range& e) {
66873       {
66874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66875       };
66876     } catch (std::exception& e) {
66877       {
66878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66879       };
66880     } catch (Dali::DaliException e) {
66881       {
66882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66883       };
66884     } catch (...) {
66885       {
66886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66887       };
66888     }
66889   }
66890
66891 }
66892
66893
66894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66895   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66896   Dali::Actor arg2 ;
66897   Dali::Actor *argp2 ;
66898
66899   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66900   argp2 = (Dali::Actor *)jarg2;
66901   if (!argp2) {
66902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66903     return ;
66904   }
66905   arg2 = *argp2;
66906   {
66907     try {
66908       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66909     } catch (std::out_of_range& e) {
66910       {
66911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66912       };
66913     } catch (std::exception& e) {
66914       {
66915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66916       };
66917     } catch (Dali::DaliException e) {
66918       {
66919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66920       };
66921     } catch (...) {
66922       {
66923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66924       };
66925     }
66926   }
66927
66928 }
66929
66930
66931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66932   unsigned int jresult ;
66933   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66934   bool result;
66935
66936   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66937   {
66938     try {
66939       result = (bool)(arg1)->OnKeyboardEnter();
66940     } catch (std::out_of_range& e) {
66941       {
66942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66943       };
66944     } catch (std::exception& e) {
66945       {
66946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66947       };
66948     } catch (Dali::DaliException e) {
66949       {
66950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66951       };
66952     } catch (...) {
66953       {
66954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66955       };
66956     }
66957   }
66958
66959   jresult = result;
66960   return jresult;
66961 }
66962
66963
66964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66965   unsigned int jresult ;
66966   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66967   bool result;
66968
66969   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66970   {
66971     try {
66972       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66973     } catch (std::out_of_range& e) {
66974       {
66975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66976       };
66977     } catch (std::exception& e) {
66978       {
66979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66980       };
66981     } catch (Dali::DaliException e) {
66982       {
66983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66984       };
66985     } catch (...) {
66986       {
66987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66988       };
66989     }
66990   }
66991
66992   jresult = result;
66993   return jresult;
66994 }
66995
66996
66997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66998   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66999   Dali::PinchGesture *arg2 = 0 ;
67000
67001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67002   arg2 = (Dali::PinchGesture *)jarg2;
67003   if (!arg2) {
67004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67005     return ;
67006   }
67007   {
67008     try {
67009       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
67010     } catch (std::out_of_range& e) {
67011       {
67012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67013       };
67014     } catch (std::exception& e) {
67015       {
67016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67017       };
67018     } catch (Dali::DaliException e) {
67019       {
67020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67021       };
67022     } catch (...) {
67023       {
67024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67025       };
67026     }
67027   }
67028
67029 }
67030
67031
67032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67033   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67034   Dali::PinchGesture *arg2 = 0 ;
67035
67036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67037   arg2 = (Dali::PinchGesture *)jarg2;
67038   if (!arg2) {
67039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67040     return ;
67041   }
67042   {
67043     try {
67044       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
67045     } catch (std::out_of_range& e) {
67046       {
67047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67048       };
67049     } catch (std::exception& e) {
67050       {
67051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67052       };
67053     } catch (Dali::DaliException e) {
67054       {
67055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67056       };
67057     } catch (...) {
67058       {
67059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67060       };
67061     }
67062   }
67063
67064 }
67065
67066
67067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
67068   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67069   Dali::PanGesture *arg2 = 0 ;
67070
67071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67072   arg2 = (Dali::PanGesture *)jarg2;
67073   if (!arg2) {
67074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67075     return ;
67076   }
67077   {
67078     try {
67079       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
67080     } catch (std::out_of_range& e) {
67081       {
67082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67083       };
67084     } catch (std::exception& e) {
67085       {
67086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67087       };
67088     } catch (Dali::DaliException e) {
67089       {
67090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67091       };
67092     } catch (...) {
67093       {
67094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67095       };
67096     }
67097   }
67098
67099 }
67100
67101
67102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67103   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67104   Dali::PanGesture *arg2 = 0 ;
67105
67106   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67107   arg2 = (Dali::PanGesture *)jarg2;
67108   if (!arg2) {
67109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67110     return ;
67111   }
67112   {
67113     try {
67114       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
67115     } catch (std::out_of_range& e) {
67116       {
67117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67118       };
67119     } catch (std::exception& e) {
67120       {
67121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67122       };
67123     } catch (Dali::DaliException e) {
67124       {
67125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67126       };
67127     } catch (...) {
67128       {
67129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67130       };
67131     }
67132   }
67133
67134 }
67135
67136
67137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
67138   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67139   Dali::TapGesture *arg2 = 0 ;
67140
67141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67142   arg2 = (Dali::TapGesture *)jarg2;
67143   if (!arg2) {
67144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67145     return ;
67146   }
67147   {
67148     try {
67149       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
67150     } catch (std::out_of_range& e) {
67151       {
67152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67153       };
67154     } catch (std::exception& e) {
67155       {
67156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67157       };
67158     } catch (Dali::DaliException e) {
67159       {
67160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67161       };
67162     } catch (...) {
67163       {
67164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67165       };
67166     }
67167   }
67168
67169 }
67170
67171
67172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67173   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67174   Dali::TapGesture *arg2 = 0 ;
67175
67176   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67177   arg2 = (Dali::TapGesture *)jarg2;
67178   if (!arg2) {
67179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67180     return ;
67181   }
67182   {
67183     try {
67184       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
67185     } catch (std::out_of_range& e) {
67186       {
67187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67188       };
67189     } catch (std::exception& e) {
67190       {
67191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67192       };
67193     } catch (Dali::DaliException e) {
67194       {
67195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67196       };
67197     } catch (...) {
67198       {
67199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67200       };
67201     }
67202   }
67203
67204 }
67205
67206
67207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
67208   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67209   Dali::LongPressGesture *arg2 = 0 ;
67210
67211   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67212   arg2 = (Dali::LongPressGesture *)jarg2;
67213   if (!arg2) {
67214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67215     return ;
67216   }
67217   {
67218     try {
67219       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
67220     } catch (std::out_of_range& e) {
67221       {
67222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67223       };
67224     } catch (std::exception& e) {
67225       {
67226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67227       };
67228     } catch (Dali::DaliException e) {
67229       {
67230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67231       };
67232     } catch (...) {
67233       {
67234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67235       };
67236     }
67237   }
67238
67239 }
67240
67241
67242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67243   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67244   Dali::LongPressGesture *arg2 = 0 ;
67245
67246   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67247   arg2 = (Dali::LongPressGesture *)jarg2;
67248   if (!arg2) {
67249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67250     return ;
67251   }
67252   {
67253     try {
67254       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
67255     } catch (std::out_of_range& e) {
67256       {
67257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67258       };
67259     } catch (std::exception& e) {
67260       {
67261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67262       };
67263     } catch (Dali::DaliException e) {
67264       {
67265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67266       };
67267     } catch (...) {
67268       {
67269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67270       };
67271     }
67272   }
67273
67274 }
67275
67276
67277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67279   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67280   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67281
67282   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67283   arg2 = (Dali::SlotObserver *)jarg2;
67284   arg3 = (Dali::CallbackBase *)jarg3;
67285   {
67286     try {
67287       (arg1)->SignalConnected(arg2,arg3);
67288     } catch (std::out_of_range& e) {
67289       {
67290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67291       };
67292     } catch (std::exception& e) {
67293       {
67294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67295       };
67296     } catch (Dali::DaliException e) {
67297       {
67298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67299       };
67300     } catch (...) {
67301       {
67302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67303       };
67304     }
67305   }
67306
67307 }
67308
67309
67310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67311   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67312   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67313   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67314
67315   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67316   arg2 = (Dali::SlotObserver *)jarg2;
67317   arg3 = (Dali::CallbackBase *)jarg3;
67318   {
67319     try {
67320       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67321     } catch (std::out_of_range& e) {
67322       {
67323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67324       };
67325     } catch (std::exception& e) {
67326       {
67327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67328       };
67329     } catch (Dali::DaliException e) {
67330       {
67331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67332       };
67333     } catch (...) {
67334       {
67335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67336       };
67337     }
67338   }
67339
67340 }
67341
67342
67343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67345   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67346   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67347
67348   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67349   arg2 = (Dali::SlotObserver *)jarg2;
67350   arg3 = (Dali::CallbackBase *)jarg3;
67351   {
67352     try {
67353       (arg1)->SignalDisconnected(arg2,arg3);
67354     } catch (std::out_of_range& e) {
67355       {
67356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67357       };
67358     } catch (std::exception& e) {
67359       {
67360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67361       };
67362     } catch (Dali::DaliException e) {
67363       {
67364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67365       };
67366     } catch (...) {
67367       {
67368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67369       };
67370     }
67371   }
67372
67373 }
67374
67375
67376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67377   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67378   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67379   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67380
67381   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67382   arg2 = (Dali::SlotObserver *)jarg2;
67383   arg3 = (Dali::CallbackBase *)jarg3;
67384   {
67385     try {
67386       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67387     } catch (std::out_of_range& e) {
67388       {
67389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67390       };
67391     } catch (std::exception& e) {
67392       {
67393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67394       };
67395     } catch (Dali::DaliException e) {
67396       {
67397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67398       };
67399     } catch (...) {
67400       {
67401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67402       };
67403     }
67404   }
67405
67406 }
67407
67408
67409 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) {
67410   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67411   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67412   if (director) {
67413     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);
67414   }
67415 }
67416
67417
67418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67419   void * jresult ;
67420   Dali::Toolkit::Control *arg1 = 0 ;
67421   Dali::Toolkit::Internal::Control *result = 0 ;
67422
67423   arg1 = (Dali::Toolkit::Control *)jarg1;
67424   if (!arg1) {
67425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67426     return 0;
67427   }
67428   {
67429     try {
67430       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67431     } catch (std::out_of_range& e) {
67432       {
67433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67434       };
67435     } catch (std::exception& e) {
67436       {
67437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67438       };
67439     } catch (Dali::DaliException e) {
67440       {
67441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67442       };
67443     } catch (...) {
67444       {
67445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67446       };
67447     }
67448   }
67449
67450   jresult = (void *)result;
67451   return jresult;
67452 }
67453
67454
67455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67456   int jresult ;
67457   int result;
67458
67459   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67460   jresult = (int)result;
67461   return jresult;
67462 }
67463
67464
67465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67466   int jresult ;
67467   int result;
67468
67469   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67470   jresult = (int)result;
67471   return jresult;
67472 }
67473
67474
67475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67476   int jresult ;
67477   int result;
67478
67479   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67480   jresult = (int)result;
67481   return jresult;
67482 }
67483
67484
67485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67486   int jresult ;
67487   int result;
67488
67489   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67490   jresult = (int)result;
67491   return jresult;
67492 }
67493
67494
67495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67496   int jresult ;
67497   int result;
67498
67499   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67500   jresult = (int)result;
67501   return jresult;
67502 }
67503
67504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67505   int jresult ;
67506   int result;
67507
67508   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67509   jresult = (int)result;
67510   return jresult;
67511 }
67512
67513
67514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67515   int jresult ;
67516   int result;
67517
67518   result = (int)Dali::Toolkit::Control::Property::PADDING;
67519   jresult = (int)result;
67520   return jresult;
67521 }
67522
67523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67524   void * jresult ;
67525   Dali::Toolkit::Control::Property *result = 0 ;
67526
67527   {
67528     try {
67529       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67530     } catch (std::out_of_range& e) {
67531       {
67532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67533       };
67534     } catch (std::exception& e) {
67535       {
67536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67537       };
67538     } catch (Dali::DaliException e) {
67539       {
67540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67541       };
67542     } catch (...) {
67543       {
67544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67545       };
67546     }
67547   }
67548
67549   jresult = (void *)result;
67550   return jresult;
67551 }
67552
67553
67554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67555   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67556
67557   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67558   {
67559     try {
67560       delete arg1;
67561     } catch (std::out_of_range& e) {
67562       {
67563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67564       };
67565     } catch (std::exception& e) {
67566       {
67567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67568       };
67569     } catch (Dali::DaliException e) {
67570       {
67571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67572       };
67573     } catch (...) {
67574       {
67575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67576       };
67577     }
67578   }
67579
67580 }
67581
67582
67583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67584   void * jresult ;
67585   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67586
67587   {
67588     try {
67589       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67590     } catch (std::out_of_range& e) {
67591       {
67592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67593       };
67594     } catch (std::exception& e) {
67595       {
67596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67597       };
67598     } catch (Dali::DaliException e) {
67599       {
67600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67601       };
67602     } catch (...) {
67603       {
67604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67605       };
67606     }
67607   }
67608
67609   jresult = (void *)result;
67610   return jresult;
67611 }
67612
67613
67614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67615   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67616
67617   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67618   {
67619     try {
67620       delete arg1;
67621     } catch (std::out_of_range& e) {
67622       {
67623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67624       };
67625     } catch (std::exception& e) {
67626       {
67627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67628       };
67629     } catch (Dali::DaliException e) {
67630       {
67631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67632       };
67633     } catch (...) {
67634       {
67635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67636       };
67637     }
67638   }
67639
67640 }
67641
67642
67643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67644   void * jresult ;
67645   Dali::Toolkit::Control result;
67646
67647   {
67648     try {
67649       result = Dali::Toolkit::Control::New();
67650     } catch (std::out_of_range& e) {
67651       {
67652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67653       };
67654     } catch (std::exception& e) {
67655       {
67656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67657       };
67658     } catch (Dali::DaliException e) {
67659       {
67660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67661       };
67662     } catch (...) {
67663       {
67664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67665       };
67666     }
67667   }
67668
67669   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67670   return jresult;
67671 }
67672
67673
67674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67675   void * jresult ;
67676   Dali::Toolkit::Control *result = 0 ;
67677
67678   {
67679     try {
67680       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67681     } catch (std::out_of_range& e) {
67682       {
67683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67684       };
67685     } catch (std::exception& e) {
67686       {
67687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67688       };
67689     } catch (Dali::DaliException e) {
67690       {
67691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67692       };
67693     } catch (...) {
67694       {
67695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67696       };
67697     }
67698   }
67699
67700   jresult = (void *)result;
67701   return jresult;
67702 }
67703
67704
67705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67706   void * jresult ;
67707   Dali::Toolkit::Control *arg1 = 0 ;
67708   Dali::Toolkit::Control *result = 0 ;
67709
67710   arg1 = (Dali::Toolkit::Control *)jarg1;
67711   if (!arg1) {
67712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67713     return 0;
67714   }
67715   {
67716     try {
67717       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67718     } catch (std::out_of_range& e) {
67719       {
67720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67721       };
67722     } catch (std::exception& e) {
67723       {
67724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67725       };
67726     } catch (Dali::DaliException e) {
67727       {
67728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67729       };
67730     } catch (...) {
67731       {
67732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67733       };
67734     }
67735   }
67736
67737   jresult = (void *)result;
67738   return jresult;
67739 }
67740
67741
67742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67743   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67744
67745   arg1 = (Dali::Toolkit::Control *)jarg1;
67746   {
67747     try {
67748       delete arg1;
67749     } catch (std::out_of_range& e) {
67750       {
67751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67752       };
67753     } catch (std::exception& e) {
67754       {
67755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67756       };
67757     } catch (Dali::DaliException e) {
67758       {
67759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67760       };
67761     } catch (...) {
67762       {
67763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67764       };
67765     }
67766   }
67767
67768 }
67769
67770
67771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67772   void * jresult ;
67773   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67774   Dali::Toolkit::Control *arg2 = 0 ;
67775   Dali::Toolkit::Control *result = 0 ;
67776
67777   arg1 = (Dali::Toolkit::Control *)jarg1;
67778   arg2 = (Dali::Toolkit::Control *)jarg2;
67779   if (!arg2) {
67780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67781     return 0;
67782   }
67783   {
67784     try {
67785       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67786     } catch (std::out_of_range& e) {
67787       {
67788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67789       };
67790     } catch (std::exception& e) {
67791       {
67792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67793       };
67794     } catch (Dali::DaliException e) {
67795       {
67796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67797       };
67798     } catch (...) {
67799       {
67800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67801       };
67802     }
67803   }
67804
67805   jresult = (void *)result;
67806   return jresult;
67807 }
67808
67809
67810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67811   void * jresult ;
67812   Dali::BaseHandle arg1 ;
67813   Dali::BaseHandle *argp1 ;
67814   Dali::Toolkit::Control result;
67815
67816   argp1 = (Dali::BaseHandle *)jarg1;
67817   if (!argp1) {
67818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67819     return 0;
67820   }
67821   arg1 = *argp1;
67822   {
67823     try {
67824       result = Dali::Toolkit::Control::DownCast(arg1);
67825     } catch (std::out_of_range& e) {
67826       {
67827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67828       };
67829     } catch (std::exception& e) {
67830       {
67831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67832       };
67833     } catch (Dali::DaliException e) {
67834       {
67835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67836       };
67837     } catch (...) {
67838       {
67839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67840       };
67841     }
67842   }
67843
67844   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67845   return jresult;
67846 }
67847
67848
67849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67850   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67851
67852   arg1 = (Dali::Toolkit::Control *)jarg1;
67853   {
67854     try {
67855       (arg1)->SetKeyInputFocus();
67856     } catch (std::out_of_range& e) {
67857       {
67858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67859       };
67860     } catch (std::exception& e) {
67861       {
67862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67863       };
67864     } catch (Dali::DaliException e) {
67865       {
67866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67867       };
67868     } catch (...) {
67869       {
67870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67871       };
67872     }
67873   }
67874
67875 }
67876
67877
67878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67879   unsigned int jresult ;
67880   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67881   bool result;
67882
67883   arg1 = (Dali::Toolkit::Control *)jarg1;
67884   {
67885     try {
67886       result = (bool)(arg1)->HasKeyInputFocus();
67887     } catch (std::out_of_range& e) {
67888       {
67889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67890       };
67891     } catch (std::exception& e) {
67892       {
67893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67894       };
67895     } catch (Dali::DaliException e) {
67896       {
67897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67898       };
67899     } catch (...) {
67900       {
67901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67902       };
67903     }
67904   }
67905
67906   jresult = result;
67907   return jresult;
67908 }
67909
67910
67911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67912   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67913
67914   arg1 = (Dali::Toolkit::Control *)jarg1;
67915   {
67916     try {
67917       (arg1)->ClearKeyInputFocus();
67918     } catch (std::out_of_range& e) {
67919       {
67920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67921       };
67922     } catch (std::exception& e) {
67923       {
67924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67925       };
67926     } catch (Dali::DaliException e) {
67927       {
67928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67929       };
67930     } catch (...) {
67931       {
67932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67933       };
67934     }
67935   }
67936
67937 }
67938
67939
67940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67941   void * jresult ;
67942   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67943   Dali::PinchGestureDetector result;
67944
67945   arg1 = (Dali::Toolkit::Control *)jarg1;
67946   {
67947     try {
67948       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67949     } catch (std::out_of_range& e) {
67950       {
67951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67952       };
67953     } catch (std::exception& e) {
67954       {
67955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67956       };
67957     } catch (Dali::DaliException e) {
67958       {
67959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67960       };
67961     } catch (...) {
67962       {
67963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67964       };
67965     }
67966   }
67967
67968   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67969   return jresult;
67970 }
67971
67972
67973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67974   void * jresult ;
67975   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67976   Dali::PanGestureDetector result;
67977
67978   arg1 = (Dali::Toolkit::Control *)jarg1;
67979   {
67980     try {
67981       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67982     } catch (std::out_of_range& e) {
67983       {
67984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67985       };
67986     } catch (std::exception& e) {
67987       {
67988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67989       };
67990     } catch (Dali::DaliException e) {
67991       {
67992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67993       };
67994     } catch (...) {
67995       {
67996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67997       };
67998     }
67999   }
68000
68001   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
68002   return jresult;
68003 }
68004
68005
68006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
68007   void * jresult ;
68008   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68009   Dali::TapGestureDetector result;
68010
68011   arg1 = (Dali::Toolkit::Control *)jarg1;
68012   {
68013     try {
68014       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
68015     } catch (std::out_of_range& e) {
68016       {
68017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68018       };
68019     } catch (std::exception& e) {
68020       {
68021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68022       };
68023     } catch (Dali::DaliException e) {
68024       {
68025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68026       };
68027     } catch (...) {
68028       {
68029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68030       };
68031     }
68032   }
68033
68034   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
68035   return jresult;
68036 }
68037
68038
68039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
68040   void * jresult ;
68041   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68042   Dali::LongPressGestureDetector result;
68043
68044   arg1 = (Dali::Toolkit::Control *)jarg1;
68045   {
68046     try {
68047       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
68048     } catch (std::out_of_range& e) {
68049       {
68050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68051       };
68052     } catch (std::exception& e) {
68053       {
68054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68055       };
68056     } catch (Dali::DaliException e) {
68057       {
68058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68059       };
68060     } catch (...) {
68061       {
68062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68063       };
68064     }
68065   }
68066
68067   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
68068   return jresult;
68069 }
68070
68071
68072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
68073   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68074   std::string *arg2 = 0 ;
68075
68076   arg1 = (Dali::Toolkit::Control *)jarg1;
68077   if (!jarg2) {
68078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68079     return ;
68080   }
68081   std::string arg2_str(jarg2);
68082   arg2 = &arg2_str;
68083   {
68084     try {
68085       (arg1)->SetStyleName((std::string const &)*arg2);
68086     } catch (std::out_of_range& e) {
68087       {
68088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68089       };
68090     } catch (std::exception& e) {
68091       {
68092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68093       };
68094     } catch (Dali::DaliException e) {
68095       {
68096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68097       };
68098     } catch (...) {
68099       {
68100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68101       };
68102     }
68103   }
68104
68105
68106   //argout typemap for const std::string&
68107
68108 }
68109
68110
68111 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
68112   char * jresult ;
68113   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68114   std::string *result = 0 ;
68115
68116   arg1 = (Dali::Toolkit::Control *)jarg1;
68117   {
68118     try {
68119       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
68120     } catch (std::out_of_range& e) {
68121       {
68122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68123       };
68124     } catch (std::exception& e) {
68125       {
68126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68127       };
68128     } catch (Dali::DaliException e) {
68129       {
68130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68131       };
68132     } catch (...) {
68133       {
68134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68135       };
68136     }
68137   }
68138
68139   jresult = SWIG_csharp_string_callback(result->c_str());
68140   return jresult;
68141 }
68142
68143
68144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
68145   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68146   Dali::Vector4 *arg2 = 0 ;
68147
68148   arg1 = (Dali::Toolkit::Control *)jarg1;
68149   arg2 = (Dali::Vector4 *)jarg2;
68150   if (!arg2) {
68151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68152     return ;
68153   }
68154   {
68155     try {
68156       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
68157     } catch (std::out_of_range& e) {
68158       {
68159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68160       };
68161     } catch (std::exception& e) {
68162       {
68163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68164       };
68165     } catch (Dali::DaliException e) {
68166       {
68167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68168       };
68169     } catch (...) {
68170       {
68171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68172       };
68173     }
68174   }
68175
68176 }
68177
68178
68179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
68180   void * jresult ;
68181   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68182   Dali::Vector4 result;
68183
68184   arg1 = (Dali::Toolkit::Control *)jarg1;
68185   {
68186     try {
68187       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
68188     } catch (std::out_of_range& e) {
68189       {
68190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68191       };
68192     } catch (std::exception& e) {
68193       {
68194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68195       };
68196     } catch (Dali::DaliException e) {
68197       {
68198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68199       };
68200     } catch (...) {
68201       {
68202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68203       };
68204     }
68205   }
68206
68207   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68208   return jresult;
68209 }
68210
68211
68212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
68213   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68214   Dali::Image arg2 ;
68215   Dali::Image *argp2 ;
68216
68217   arg1 = (Dali::Toolkit::Control *)jarg1;
68218   argp2 = (Dali::Image *)jarg2;
68219   if (!argp2) {
68220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
68221     return ;
68222   }
68223   arg2 = *argp2;
68224   {
68225     try {
68226       (arg1)->SetBackgroundImage(arg2);
68227     } catch (std::out_of_range& e) {
68228       {
68229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68230       };
68231     } catch (std::exception& e) {
68232       {
68233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68234       };
68235     } catch (Dali::DaliException e) {
68236       {
68237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68238       };
68239     } catch (...) {
68240       {
68241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68242       };
68243     }
68244   }
68245
68246 }
68247
68248
68249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
68250   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68251
68252   arg1 = (Dali::Toolkit::Control *)jarg1;
68253   {
68254     try {
68255       (arg1)->ClearBackground();
68256     } catch (std::out_of_range& e) {
68257       {
68258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68259       };
68260     } catch (std::exception& e) {
68261       {
68262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68263       };
68264     } catch (Dali::DaliException e) {
68265       {
68266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68267       };
68268     } catch (...) {
68269       {
68270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68271       };
68272     }
68273   }
68274
68275 }
68276
68277
68278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68279   void * jresult ;
68280   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68281   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68282
68283   arg1 = (Dali::Toolkit::Control *)jarg1;
68284   {
68285     try {
68286       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68287     } catch (std::out_of_range& e) {
68288       {
68289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68290       };
68291     } catch (std::exception& e) {
68292       {
68293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68294       };
68295     } catch (Dali::DaliException e) {
68296       {
68297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68298       };
68299     } catch (...) {
68300       {
68301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68302       };
68303     }
68304   }
68305
68306   jresult = (void *)result;
68307   return jresult;
68308 }
68309
68310
68311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68312   void * jresult ;
68313   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68314   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68315
68316   arg1 = (Dali::Toolkit::Control *)jarg1;
68317   {
68318     try {
68319       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68320     } catch (std::out_of_range& e) {
68321       {
68322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68323       };
68324     } catch (std::exception& e) {
68325       {
68326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68327       };
68328     } catch (Dali::DaliException e) {
68329       {
68330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68331       };
68332     } catch (...) {
68333       {
68334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68335       };
68336     }
68337   }
68338
68339   jresult = (void *)result;
68340   return jresult;
68341 }
68342
68343
68344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68345   void * jresult ;
68346   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68347   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68348
68349   arg1 = (Dali::Toolkit::Control *)jarg1;
68350   {
68351     try {
68352       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68353     } catch (std::out_of_range& e) {
68354       {
68355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68356       };
68357     } catch (std::exception& e) {
68358       {
68359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68360       };
68361     } catch (Dali::DaliException e) {
68362       {
68363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68364       };
68365     } catch (...) {
68366       {
68367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68368       };
68369     }
68370   }
68371
68372   jresult = (void *)result;
68373   return jresult;
68374 }
68375
68376
68377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68378   void * jresult ;
68379   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68380   Dali::Toolkit::Control *result = 0 ;
68381
68382   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68383   if (!arg1) {
68384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68385     return 0;
68386   }
68387   {
68388     try {
68389       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68390     } catch (std::out_of_range& e) {
68391       {
68392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68393       };
68394     } catch (std::exception& e) {
68395       {
68396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68397       };
68398     } catch (Dali::DaliException e) {
68399       {
68400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68401       };
68402     } catch (...) {
68403       {
68404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68405       };
68406     }
68407   }
68408
68409   jresult = (void *)result;
68410   return jresult;
68411 }
68412
68413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68414 {
68415   int jresult;
68416   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68417   arg1 = (Dali::Toolkit::Control *)jarg1;
68418
68419   if (!arg1) {
68420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68421     return 0;
68422   }
68423
68424   Dali::Property::Index arg2 = 0 ;
68425   arg2 = (Dali::Property::Index)jarg2;
68426
68427   Toolkit::Visual::ResourceStatus result;
68428   {
68429     try {
68430       result = arg1->GetVisualResourceStatus(arg2);
68431     } catch (std::out_of_range& e) {
68432       {
68433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68434       };
68435     } catch (std::exception& e) {
68436       {
68437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68438       };
68439     } catch (...) {
68440       {
68441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68442       };
68443     }
68444   }
68445   jresult = (int)(result);
68446   return jresult;
68447 }
68448
68449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68450 {
68451   void * jresult;
68452   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68453   arg1 = (Dali::Toolkit::Control *)jarg1;
68454
68455   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68456
68457   Dali::Toolkit::TransitionData *arg2 = 0 ;
68458   Dali::Animation result;
68459
68460   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68461   if (!arg2) {
68462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68463     return 0;
68464   }
68465   {
68466     try {
68467       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68468     } catch (std::out_of_range& e) {
68469       {
68470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68471       };
68472     } catch (std::exception& e) {
68473       {
68474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68475       };
68476     } catch (Dali::DaliException e) {
68477       {
68478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68479       };
68480     } catch (...) {
68481       {
68482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68483       };
68484     }
68485   }
68486
68487   jresult = new Dali::Animation((const Dali::Animation &)result);
68488   return jresult;
68489 }
68490
68491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68492 {
68493   Dali::Toolkit::Control arg1;
68494   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68495
68496   if (!argp1) {
68497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68498   }
68499   arg1 = *argp1;
68500
68501   Dali::Property::Index arg2 = 0 ;
68502   arg2 = (Dali::Property::Index)jarg2;
68503
68504   Dali::Property::Index arg3 = 0 ;
68505   arg3 = (Dali::Property::Index)jarg3;
68506
68507   Dali::Property::Value arg4;
68508   arg4 = (Dali::Property::Value *)jarg4;
68509
68510   {
68511     try {
68512       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68513     } catch (std::out_of_range& e) {
68514       {
68515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68516       };
68517     } catch (std::exception& e) {
68518       {
68519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68520       };
68521     } catch (...) {
68522       {
68523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68524       };
68525     }
68526   }
68527
68528
68529 }
68530
68531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68532   void * jresult ;
68533   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68534   Dali::Toolkit::LayoutItem result;
68535
68536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68537   if (!arg1) {
68538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68539     return 0;
68540   }
68541   {
68542     try {
68543       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68544     } catch (std::out_of_range& e) {
68545       {
68546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68547       };
68548     } catch (std::exception& e) {
68549       {
68550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68551       };
68552     } catch (...) {
68553       {
68554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68555       };
68556     }
68557   }
68558   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68559   return jresult;
68560 }
68561
68562
68563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68564   void * jresult ;
68565   Dali::Toolkit::Control arg1 ;
68566   Dali::Toolkit::Control *argp1 ;
68567   Dali::Toolkit::LayoutItem result;
68568
68569   argp1 = (Dali::Toolkit::Control *)jarg1;
68570   if (!argp1) {
68571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68572     return 0;
68573   }
68574   arg1 = *argp1;
68575   {
68576     try {
68577       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68578     } catch (std::out_of_range& e) {
68579       {
68580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68581       };
68582     } catch (std::exception& e) {
68583       {
68584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68585       };
68586     } catch (...) {
68587       {
68588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68589       };
68590     }
68591   }
68592   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68593   return jresult;
68594 }
68595
68596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68597   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68598   Dali::Toolkit::LayoutItem arg2 ;
68599   Dali::Toolkit::LayoutItem *argp2 ;
68600
68601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68602   if (!arg1) {
68603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68604     return ;
68605   }
68606   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68607   if (!argp2) {
68608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68609     return ;
68610   }
68611   arg2 = *argp2;
68612   {
68613     try {
68614       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68615     } catch (std::out_of_range& e) {
68616       {
68617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68618       };
68619     } catch (std::exception& e) {
68620       {
68621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68622       };
68623     } catch (...) {
68624       {
68625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68626       };
68627     }
68628   }
68629 }
68630
68631
68632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68633   Dali::Toolkit::Control arg1 ;
68634   Dali::Toolkit::LayoutItem arg2 ;
68635   Dali::Toolkit::Control *argp1 ;
68636   Dali::Toolkit::LayoutItem *argp2 ;
68637
68638   argp1 = (Dali::Toolkit::Control *)jarg1;
68639   if (!argp1) {
68640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68641     return ;
68642   }
68643   arg1 = *argp1;
68644   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68645   if (!argp2) {
68646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68647     return ;
68648   }
68649   arg2 = *argp2;
68650   {
68651     try {
68652       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68653     } catch (std::out_of_range& e) {
68654       {
68655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68656       };
68657     } catch (std::exception& e) {
68658       {
68659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68660       };
68661     } catch (...) {
68662       {
68663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68664       };
68665     }
68666   }
68667 }
68668
68669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68670   void * jresult ;
68671   Dali::Toolkit::Control *arg1 = 0 ;
68672   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68673
68674   arg1 = (Dali::Toolkit::Control *)jarg1;
68675   if (!arg1) {
68676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68677     return 0;
68678   }
68679   {
68680     try {
68681       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68682     } catch (std::out_of_range& e) {
68683       {
68684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68685       };
68686     } catch (std::exception& e) {
68687       {
68688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68689       };
68690     } catch (Dali::DaliException e) {
68691       {
68692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68693       };
68694     } catch (...) {
68695       {
68696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68697       };
68698     }
68699   }
68700
68701   jresult = (void *)result;
68702   return jresult;
68703 }
68704
68705
68706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68707   unsigned int jresult ;
68708   Dali::Toolkit::Control *arg1 = 0 ;
68709   bool result;
68710
68711   arg1 = (Dali::Toolkit::Control *)jarg1;
68712   if (!arg1) {
68713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68714     return 0;
68715   }
68716   {
68717     try {
68718       result = (bool)arg1->IsResourceReady();
68719     } catch (std::out_of_range& e) {
68720       {
68721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68722       };
68723     } catch (std::exception& e) {
68724       {
68725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68726       };
68727     } catch (Dali::DaliException e) {
68728       {
68729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68730       };
68731     } catch (...) {
68732       {
68733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68734       };
68735     }
68736   }
68737
68738   jresult = result;
68739   return jresult;
68740 }
68741
68742
68743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68744   void * jresult ;
68745   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68746
68747   {
68748     try {
68749       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68750     } catch (std::out_of_range& e) {
68751       {
68752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68753       };
68754     } catch (std::exception& e) {
68755       {
68756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68757       };
68758     } catch (Dali::DaliException e) {
68759       {
68760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68761       };
68762     } catch (...) {
68763       {
68764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68765       };
68766     }
68767   }
68768
68769   jresult = (void *)result;
68770   return jresult;
68771 }
68772
68773
68774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68775   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68776
68777   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68778   {
68779     try {
68780       delete arg1;
68781     } catch (std::out_of_range& e) {
68782       {
68783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68784       };
68785     } catch (std::exception& e) {
68786       {
68787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68788       };
68789     } catch (Dali::DaliException e) {
68790       {
68791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68792       };
68793     } catch (...) {
68794       {
68795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68796       };
68797     }
68798   }
68799
68800 }
68801
68802
68803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68804   void * jresult ;
68805   Dali::Toolkit::KeyInputFocusManager result;
68806
68807   {
68808     try {
68809       result = Dali::Toolkit::KeyInputFocusManager::Get();
68810     } catch (std::out_of_range& e) {
68811       {
68812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68813       };
68814     } catch (std::exception& e) {
68815       {
68816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68817       };
68818     } catch (Dali::DaliException e) {
68819       {
68820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68821       };
68822     } catch (...) {
68823       {
68824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68825       };
68826     }
68827   }
68828
68829   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68830   return jresult;
68831 }
68832
68833
68834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68835   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68836   Dali::Toolkit::Control arg2 ;
68837   Dali::Toolkit::Control *argp2 ;
68838
68839   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68840   argp2 = (Dali::Toolkit::Control *)jarg2;
68841   if (!argp2) {
68842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68843     return ;
68844   }
68845   arg2 = *argp2;
68846   {
68847     try {
68848       (arg1)->SetFocus(arg2);
68849     } catch (std::out_of_range& e) {
68850       {
68851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68852       };
68853     } catch (std::exception& e) {
68854       {
68855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68856       };
68857     } catch (Dali::DaliException e) {
68858       {
68859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68860       };
68861     } catch (...) {
68862       {
68863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68864       };
68865     }
68866   }
68867
68868 }
68869
68870
68871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68872   void * jresult ;
68873   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68874   Dali::Toolkit::Control result;
68875
68876   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68877   {
68878     try {
68879       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68880     } catch (std::out_of_range& e) {
68881       {
68882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68883       };
68884     } catch (std::exception& e) {
68885       {
68886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68887       };
68888     } catch (Dali::DaliException e) {
68889       {
68890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68891       };
68892     } catch (...) {
68893       {
68894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68895       };
68896     }
68897   }
68898
68899   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68900   return jresult;
68901 }
68902
68903
68904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68905   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68906   Dali::Toolkit::Control arg2 ;
68907   Dali::Toolkit::Control *argp2 ;
68908
68909   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68910   argp2 = (Dali::Toolkit::Control *)jarg2;
68911   if (!argp2) {
68912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68913     return ;
68914   }
68915   arg2 = *argp2;
68916   {
68917     try {
68918       (arg1)->RemoveFocus(arg2);
68919     } catch (std::out_of_range& e) {
68920       {
68921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68922       };
68923     } catch (std::exception& e) {
68924       {
68925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68926       };
68927     } catch (Dali::DaliException e) {
68928       {
68929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68930       };
68931     } catch (...) {
68932       {
68933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68934       };
68935     }
68936   }
68937
68938 }
68939
68940
68941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68942   void * jresult ;
68943   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68944   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68945
68946   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68947   {
68948     try {
68949       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68950     } catch (std::out_of_range& e) {
68951       {
68952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68953       };
68954     } catch (std::exception& e) {
68955       {
68956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68957       };
68958     } catch (Dali::DaliException e) {
68959       {
68960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68961       };
68962     } catch (...) {
68963       {
68964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68965       };
68966     }
68967   }
68968
68969   jresult = (void *)result;
68970   return jresult;
68971 }
68972
68973
68974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68975   void * jresult ;
68976   Dali::Toolkit::Alignment::Padding *result = 0 ;
68977
68978   {
68979     try {
68980       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68981     } catch (std::out_of_range& e) {
68982       {
68983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68984       };
68985     } catch (std::exception& e) {
68986       {
68987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68988       };
68989     } catch (Dali::DaliException e) {
68990       {
68991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68992       };
68993     } catch (...) {
68994       {
68995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68996       };
68997     }
68998   }
68999
69000   jresult = (void *)result;
69001   return jresult;
69002 }
69003
69004
69005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
69006   void * jresult ;
69007   float arg1 ;
69008   float arg2 ;
69009   float arg3 ;
69010   float arg4 ;
69011   Dali::Toolkit::Alignment::Padding *result = 0 ;
69012
69013   arg1 = (float)jarg1;
69014   arg2 = (float)jarg2;
69015   arg3 = (float)jarg3;
69016   arg4 = (float)jarg4;
69017   {
69018     try {
69019       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
69020     } catch (std::out_of_range& e) {
69021       {
69022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69023       };
69024     } catch (std::exception& e) {
69025       {
69026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69027       };
69028     } catch (Dali::DaliException e) {
69029       {
69030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69031       };
69032     } catch (...) {
69033       {
69034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69035       };
69036     }
69037   }
69038
69039   jresult = (void *)result;
69040   return jresult;
69041 }
69042
69043
69044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
69045   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69046   float arg2 ;
69047
69048   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69049   arg2 = (float)jarg2;
69050   if (arg1) (arg1)->left = arg2;
69051 }
69052
69053
69054 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
69055   float jresult ;
69056   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69057   float result;
69058
69059   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69060   result = (float) ((arg1)->left);
69061   jresult = result;
69062   return jresult;
69063 }
69064
69065
69066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
69067   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69068   float arg2 ;
69069
69070   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69071   arg2 = (float)jarg2;
69072   if (arg1) (arg1)->right = arg2;
69073 }
69074
69075
69076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69077   float jresult ;
69078   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69079   float result;
69080
69081   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69082   result = (float) ((arg1)->right);
69083   jresult = result;
69084   return jresult;
69085 }
69086
69087
69088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69089   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69090   float arg2 ;
69091
69092   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69093   arg2 = (float)jarg2;
69094   if (arg1) (arg1)->top = arg2;
69095 }
69096
69097
69098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69099   float jresult ;
69100   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69101   float result;
69102
69103   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69104   result = (float) ((arg1)->top);
69105   jresult = result;
69106   return jresult;
69107 }
69108
69109
69110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69111   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69112   float arg2 ;
69113
69114   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69115   arg2 = (float)jarg2;
69116   if (arg1) (arg1)->bottom = arg2;
69117 }
69118
69119
69120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69121   float jresult ;
69122   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69123   float result;
69124
69125   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69126   result = (float) ((arg1)->bottom);
69127   jresult = result;
69128   return jresult;
69129 }
69130
69131
69132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69133   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69134
69135   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69136   {
69137     try {
69138       delete arg1;
69139     } catch (std::out_of_range& e) {
69140       {
69141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69142       };
69143     } catch (std::exception& e) {
69144       {
69145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69146       };
69147     } catch (Dali::DaliException e) {
69148       {
69149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69150       };
69151     } catch (...) {
69152       {
69153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69154       };
69155     }
69156   }
69157
69158 }
69159
69160
69161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69162   void * jresult ;
69163   Dali::Toolkit::Alignment *result = 0 ;
69164
69165   {
69166     try {
69167       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69168     } catch (std::out_of_range& e) {
69169       {
69170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69171       };
69172     } catch (std::exception& e) {
69173       {
69174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69175       };
69176     } catch (Dali::DaliException e) {
69177       {
69178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69179       };
69180     } catch (...) {
69181       {
69182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69183       };
69184     }
69185   }
69186
69187   jresult = (void *)result;
69188   return jresult;
69189 }
69190
69191
69192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69193   void * jresult ;
69194   Dali::Toolkit::Alignment::Type arg1 ;
69195   Dali::Toolkit::Alignment::Type arg2 ;
69196   Dali::Toolkit::Alignment result;
69197
69198   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69199   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69200   {
69201     try {
69202       result = Dali::Toolkit::Alignment::New(arg1,arg2);
69203     } catch (std::out_of_range& e) {
69204       {
69205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69206       };
69207     } catch (std::exception& e) {
69208       {
69209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (Dali::DaliException e) {
69212       {
69213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69214       };
69215     } catch (...) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69218       };
69219     }
69220   }
69221
69222   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69223   return jresult;
69224 }
69225
69226
69227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69228   void * jresult ;
69229   Dali::Toolkit::Alignment::Type arg1 ;
69230   Dali::Toolkit::Alignment result;
69231
69232   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69233   {
69234     try {
69235       result = Dali::Toolkit::Alignment::New(arg1);
69236     } catch (std::out_of_range& e) {
69237       {
69238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69239       };
69240     } catch (std::exception& e) {
69241       {
69242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69243       };
69244     } catch (Dali::DaliException e) {
69245       {
69246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69247       };
69248     } catch (...) {
69249       {
69250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69251       };
69252     }
69253   }
69254
69255   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69256   return jresult;
69257 }
69258
69259
69260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69261   void * jresult ;
69262   Dali::Toolkit::Alignment result;
69263
69264   {
69265     try {
69266       result = Dali::Toolkit::Alignment::New();
69267     } catch (std::out_of_range& e) {
69268       {
69269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69270       };
69271     } catch (std::exception& e) {
69272       {
69273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69274       };
69275     } catch (Dali::DaliException e) {
69276       {
69277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69278       };
69279     } catch (...) {
69280       {
69281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69282       };
69283     }
69284   }
69285
69286   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69287   return jresult;
69288 }
69289
69290
69291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69292   void * jresult ;
69293   Dali::Toolkit::Alignment *arg1 = 0 ;
69294   Dali::Toolkit::Alignment *result = 0 ;
69295
69296   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69297   if (!arg1) {
69298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69299     return 0;
69300   }
69301   {
69302     try {
69303       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69304     } catch (std::out_of_range& e) {
69305       {
69306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69307       };
69308     } catch (std::exception& e) {
69309       {
69310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69311       };
69312     } catch (Dali::DaliException e) {
69313       {
69314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69315       };
69316     } catch (...) {
69317       {
69318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69319       };
69320     }
69321   }
69322
69323   jresult = (void *)result;
69324   return jresult;
69325 }
69326
69327
69328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69329   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69330
69331   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69332   {
69333     try {
69334       delete arg1;
69335     } catch (std::out_of_range& e) {
69336       {
69337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69338       };
69339     } catch (std::exception& e) {
69340       {
69341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69342       };
69343     } catch (Dali::DaliException e) {
69344       {
69345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69346       };
69347     } catch (...) {
69348       {
69349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69350       };
69351     }
69352   }
69353
69354 }
69355
69356
69357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69358   void * jresult ;
69359   Dali::BaseHandle arg1 ;
69360   Dali::BaseHandle *argp1 ;
69361   Dali::Toolkit::Alignment result;
69362
69363   argp1 = (Dali::BaseHandle *)jarg1;
69364   if (!argp1) {
69365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69366     return 0;
69367   }
69368   arg1 = *argp1;
69369   {
69370     try {
69371       result = Dali::Toolkit::Alignment::DownCast(arg1);
69372     } catch (std::out_of_range& e) {
69373       {
69374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69375       };
69376     } catch (std::exception& e) {
69377       {
69378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69379       };
69380     } catch (Dali::DaliException e) {
69381       {
69382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69383       };
69384     } catch (...) {
69385       {
69386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69387       };
69388     }
69389   }
69390
69391   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69392   return jresult;
69393 }
69394
69395
69396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69397   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69398   Dali::Toolkit::Alignment::Type arg2 ;
69399
69400   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69401   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69402   {
69403     try {
69404       (arg1)->SetAlignmentType(arg2);
69405     } catch (std::out_of_range& e) {
69406       {
69407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69408       };
69409     } catch (std::exception& e) {
69410       {
69411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69412       };
69413     } catch (Dali::DaliException e) {
69414       {
69415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69416       };
69417     } catch (...) {
69418       {
69419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69420       };
69421     }
69422   }
69423
69424 }
69425
69426
69427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69428   int jresult ;
69429   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69430   Dali::Toolkit::Alignment::Type result;
69431
69432   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69433   {
69434     try {
69435       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69436     } catch (std::out_of_range& e) {
69437       {
69438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69439       };
69440     } catch (std::exception& e) {
69441       {
69442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69443       };
69444     } catch (Dali::DaliException e) {
69445       {
69446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69447       };
69448     } catch (...) {
69449       {
69450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69451       };
69452     }
69453   }
69454
69455   jresult = (int)result;
69456   return jresult;
69457 }
69458
69459
69460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69461   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69462   Dali::Toolkit::Alignment::Scaling arg2 ;
69463
69464   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69465   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69466   {
69467     try {
69468       (arg1)->SetScaling(arg2);
69469     } catch (std::out_of_range& e) {
69470       {
69471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69472       };
69473     } catch (std::exception& e) {
69474       {
69475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69476       };
69477     } catch (Dali::DaliException e) {
69478       {
69479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69480       };
69481     } catch (...) {
69482       {
69483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69484       };
69485     }
69486   }
69487
69488 }
69489
69490
69491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69492   int jresult ;
69493   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69494   Dali::Toolkit::Alignment::Scaling result;
69495
69496   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69497   {
69498     try {
69499       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69500     } catch (std::out_of_range& e) {
69501       {
69502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69503       };
69504     } catch (std::exception& e) {
69505       {
69506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69507       };
69508     } catch (Dali::DaliException e) {
69509       {
69510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69511       };
69512     } catch (...) {
69513       {
69514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69515       };
69516     }
69517   }
69518
69519   jresult = (int)result;
69520   return jresult;
69521 }
69522
69523
69524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69525   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69526   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69527
69528   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69529   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69530   if (!arg2) {
69531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69532     return ;
69533   }
69534   {
69535     try {
69536       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69537     } catch (std::out_of_range& e) {
69538       {
69539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69540       };
69541     } catch (std::exception& e) {
69542       {
69543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69544       };
69545     } catch (Dali::DaliException e) {
69546       {
69547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69548       };
69549     } catch (...) {
69550       {
69551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69552       };
69553     }
69554   }
69555
69556 }
69557
69558
69559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69560   void * jresult ;
69561   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69562   Dali::Toolkit::Alignment::Padding *result = 0 ;
69563
69564   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69565   {
69566     try {
69567       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69568     } catch (std::out_of_range& e) {
69569       {
69570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69571       };
69572     } catch (std::exception& e) {
69573       {
69574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69575       };
69576     } catch (Dali::DaliException e) {
69577       {
69578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69579       };
69580     } catch (...) {
69581       {
69582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69583       };
69584     }
69585   }
69586
69587   jresult = (void *)result;
69588   return jresult;
69589 }
69590
69591
69592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69593   void * jresult ;
69594   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69595   Dali::Toolkit::Alignment *arg2 = 0 ;
69596   Dali::Toolkit::Alignment *result = 0 ;
69597
69598   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69599   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69600   if (!arg2) {
69601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69602     return 0;
69603   }
69604   {
69605     try {
69606       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69607     } catch (std::out_of_range& e) {
69608       {
69609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69610       };
69611     } catch (std::exception& e) {
69612       {
69613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69614       };
69615     } catch (Dali::DaliException e) {
69616       {
69617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69618       };
69619     } catch (...) {
69620       {
69621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69622       };
69623     }
69624   }
69625
69626   jresult = (void *)result;
69627   return jresult;
69628 }
69629
69630
69631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69632   int jresult ;
69633   int result;
69634
69635   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69636   jresult = (int)result;
69637   return jresult;
69638 }
69639
69640
69641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69642   int jresult ;
69643   int result;
69644
69645   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69646   jresult = (int)result;
69647   return jresult;
69648 }
69649
69650
69651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69652   int jresult ;
69653   int result;
69654
69655   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69656   jresult = (int)result;
69657   return jresult;
69658 }
69659
69660
69661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69662   int jresult ;
69663   int result;
69664
69665   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69666   jresult = (int)result;
69667   return jresult;
69668 }
69669
69670
69671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69672   int jresult ;
69673   int result;
69674
69675   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69676   jresult = (int)result;
69677   return jresult;
69678 }
69679
69680
69681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69682   int jresult ;
69683   int result;
69684
69685   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69686   jresult = (int)result;
69687   return jresult;
69688 }
69689
69690
69691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69692   int jresult ;
69693   int result;
69694
69695   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69696   jresult = (int)result;
69697   return jresult;
69698 }
69699
69700
69701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69702   int jresult ;
69703   int result;
69704
69705   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69706   jresult = (int)result;
69707   return jresult;
69708 }
69709
69710
69711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69712   int jresult ;
69713   int result;
69714
69715   result = (int)Dali::Toolkit::Button::Property::LABEL;
69716   jresult = (int)result;
69717   return jresult;
69718 }
69719
69720
69721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69722   int jresult ;
69723   int result;
69724
69725   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69726   jresult = (int)result;
69727   return jresult;
69728 }
69729
69730
69731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69732   void * jresult ;
69733   Dali::Toolkit::Button::Property *result = 0 ;
69734
69735   {
69736     try {
69737       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69738     } catch (std::out_of_range& e) {
69739       {
69740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69741       };
69742     } catch (std::exception& e) {
69743       {
69744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69745       };
69746     } catch (Dali::DaliException e) {
69747       {
69748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69749       };
69750     } catch (...) {
69751       {
69752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69753       };
69754     }
69755   }
69756
69757   jresult = (void *)result;
69758   return jresult;
69759 }
69760
69761
69762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69763   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69764
69765   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69766   {
69767     try {
69768       delete arg1;
69769     } catch (std::out_of_range& e) {
69770       {
69771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69772       };
69773     } catch (std::exception& e) {
69774       {
69775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69776       };
69777     } catch (Dali::DaliException e) {
69778       {
69779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69780       };
69781     } catch (...) {
69782       {
69783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69784       };
69785     }
69786   }
69787
69788 }
69789
69790
69791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69792   void * jresult ;
69793   Dali::Toolkit::Button *result = 0 ;
69794
69795   {
69796     try {
69797       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69798     } catch (std::out_of_range& e) {
69799       {
69800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69801       };
69802     } catch (std::exception& e) {
69803       {
69804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69805       };
69806     } catch (Dali::DaliException e) {
69807       {
69808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69809       };
69810     } catch (...) {
69811       {
69812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69813       };
69814     }
69815   }
69816
69817   jresult = (void *)result;
69818   return jresult;
69819 }
69820
69821
69822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69823   void * jresult ;
69824   Dali::Toolkit::Button *arg1 = 0 ;
69825   Dali::Toolkit::Button *result = 0 ;
69826
69827   arg1 = (Dali::Toolkit::Button *)jarg1;
69828   if (!arg1) {
69829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69830     return 0;
69831   }
69832   {
69833     try {
69834       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69835     } catch (std::out_of_range& e) {
69836       {
69837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69838       };
69839     } catch (std::exception& e) {
69840       {
69841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69842       };
69843     } catch (Dali::DaliException e) {
69844       {
69845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69846       };
69847     } catch (...) {
69848       {
69849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69850       };
69851     }
69852   }
69853
69854   jresult = (void *)result;
69855   return jresult;
69856 }
69857
69858
69859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69860   void * jresult ;
69861   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69862   Dali::Toolkit::Button *arg2 = 0 ;
69863   Dali::Toolkit::Button *result = 0 ;
69864
69865   arg1 = (Dali::Toolkit::Button *)jarg1;
69866   arg2 = (Dali::Toolkit::Button *)jarg2;
69867   if (!arg2) {
69868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69869     return 0;
69870   }
69871   {
69872     try {
69873       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69874     } catch (std::out_of_range& e) {
69875       {
69876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69877       };
69878     } catch (std::exception& e) {
69879       {
69880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69881       };
69882     } catch (Dali::DaliException e) {
69883       {
69884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69885       };
69886     } catch (...) {
69887       {
69888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69889       };
69890     }
69891   }
69892
69893   jresult = (void *)result;
69894   return jresult;
69895 }
69896
69897
69898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69899   void * jresult ;
69900   Dali::BaseHandle arg1 ;
69901   Dali::BaseHandle *argp1 ;
69902   Dali::Toolkit::Button result;
69903
69904   argp1 = (Dali::BaseHandle *)jarg1;
69905   if (!argp1) {
69906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69907     return 0;
69908   }
69909   arg1 = *argp1;
69910   {
69911     try {
69912       result = Dali::Toolkit::Button::DownCast(arg1);
69913     } catch (std::out_of_range& e) {
69914       {
69915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69916       };
69917     } catch (std::exception& e) {
69918       {
69919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69920       };
69921     } catch (Dali::DaliException e) {
69922       {
69923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69924       };
69925     } catch (...) {
69926       {
69927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69928       };
69929     }
69930   }
69931
69932   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69933   return jresult;
69934 }
69935
69936
69937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69938   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69939
69940   arg1 = (Dali::Toolkit::Button *)jarg1;
69941   {
69942     try {
69943       delete arg1;
69944     } catch (std::out_of_range& e) {
69945       {
69946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69947       };
69948     } catch (std::exception& e) {
69949       {
69950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69951       };
69952     } catch (Dali::DaliException e) {
69953       {
69954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69955       };
69956     } catch (...) {
69957       {
69958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69959       };
69960     }
69961   }
69962
69963 }
69964
69965
69966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69967   unsigned int jresult ;
69968   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69969   bool result;
69970
69971   arg1 = (Dali::Toolkit::Button *)jarg1;
69972   {
69973     try {
69974       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69975     } catch (std::out_of_range& e) {
69976       {
69977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69978       };
69979     } catch (std::exception& e) {
69980       {
69981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69982       };
69983     } catch (Dali::DaliException e) {
69984       {
69985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69986       };
69987     } catch (...) {
69988       {
69989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69990       };
69991     }
69992   }
69993
69994   jresult = result;
69995   return jresult;
69996 }
69997
69998
69999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
70000   unsigned int jresult ;
70001   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70002   bool result;
70003
70004   arg1 = (Dali::Toolkit::Button *)jarg1;
70005   {
70006     try {
70007       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
70008     } catch (std::out_of_range& e) {
70009       {
70010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70011       };
70012     } catch (std::exception& e) {
70013       {
70014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70015       };
70016     } catch (Dali::DaliException e) {
70017       {
70018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70019       };
70020     } catch (...) {
70021       {
70022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70023       };
70024     }
70025   }
70026
70027   jresult = result;
70028   return jresult;
70029 }
70030
70031
70032 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
70033   float jresult ;
70034   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70035   float result;
70036
70037   arg1 = (Dali::Toolkit::Button *)jarg1;
70038   {
70039     try {
70040       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
70041     } catch (std::out_of_range& e) {
70042       {
70043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70044       };
70045     } catch (std::exception& e) {
70046       {
70047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70048       };
70049     } catch (Dali::DaliException e) {
70050       {
70051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70052       };
70053     } catch (...) {
70054       {
70055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70056       };
70057     }
70058   }
70059
70060   jresult = result;
70061   return jresult;
70062 }
70063
70064
70065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
70066   float jresult ;
70067   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70068   float result;
70069
70070   arg1 = (Dali::Toolkit::Button *)jarg1;
70071   {
70072     try {
70073       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70074     } catch (std::out_of_range& e) {
70075       {
70076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70077       };
70078     } catch (std::exception& e) {
70079       {
70080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70081       };
70082     } catch (Dali::DaliException e) {
70083       {
70084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70085       };
70086     } catch (...) {
70087       {
70088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70089       };
70090     }
70091   }
70092
70093   jresult = result;
70094   return jresult;
70095 }
70096
70097
70098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70099   unsigned int jresult ;
70100   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70101   bool result;
70102
70103   arg1 = (Dali::Toolkit::Button *)jarg1;
70104   {
70105     try {
70106       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70107     } catch (std::out_of_range& e) {
70108       {
70109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70110       };
70111     } catch (std::exception& e) {
70112       {
70113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70114       };
70115     } catch (Dali::DaliException e) {
70116       {
70117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70118       };
70119     } catch (...) {
70120       {
70121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70122       };
70123     }
70124   }
70125
70126   jresult = result;
70127   return jresult;
70128 }
70129
70130
70131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70132   unsigned int jresult ;
70133   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70134   bool result;
70135
70136   arg1 = (Dali::Toolkit::Button *)jarg1;
70137   {
70138     try {
70139       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70140     } catch (std::out_of_range& e) {
70141       {
70142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70143       };
70144     } catch (std::exception& e) {
70145       {
70146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70147       };
70148     } catch (Dali::DaliException e) {
70149       {
70150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70151       };
70152     } catch (...) {
70153       {
70154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70155       };
70156     }
70157   }
70158
70159   jresult = result;
70160   return jresult;
70161 }
70162
70163
70164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70165   float jresult ;
70166   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70167   float result;
70168
70169   arg1 = (Dali::Toolkit::Button *)jarg1;
70170   {
70171     try {
70172       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70173     } catch (std::out_of_range& e) {
70174       {
70175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70176       };
70177     } catch (std::exception& e) {
70178       {
70179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70180       };
70181     } catch (Dali::DaliException e) {
70182       {
70183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70184       };
70185     } catch (...) {
70186       {
70187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70188       };
70189     }
70190   }
70191
70192   jresult = result;
70193   return jresult;
70194 }
70195
70196
70197 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70198   char * jresult ;
70199   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70200   std::string result;
70201
70202   arg1 = (Dali::Toolkit::Button *)jarg1;
70203   {
70204     try {
70205       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70206     } catch (std::out_of_range& e) {
70207       {
70208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70209       };
70210     } catch (std::exception& e) {
70211       {
70212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70213       };
70214     } catch (Dali::DaliException e) {
70215       {
70216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70217       };
70218     } catch (...) {
70219       {
70220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70221       };
70222     }
70223   }
70224
70225   jresult = SWIG_csharp_string_callback((&result)->c_str());
70226   return jresult;
70227 }
70228
70229
70230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70231   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70232   Dali::Actor arg2 ;
70233   Dali::Actor *argp2 ;
70234
70235   arg1 = (Dali::Toolkit::Button *)jarg1;
70236   argp2 = (Dali::Actor *)jarg2;
70237   if (!argp2) {
70238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70239     return ;
70240   }
70241   arg2 = *argp2;
70242   {
70243     try {
70244       (arg1)->SetLabel(arg2);
70245     } catch (std::out_of_range& e) {
70246       {
70247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70248       };
70249     } catch (std::exception& e) {
70250       {
70251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70252       };
70253     } catch (Dali::DaliException e) {
70254       {
70255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70256       };
70257     } catch (...) {
70258       {
70259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70260       };
70261     }
70262   }
70263
70264 }
70265
70266
70267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70268   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70269   Dali::Image arg2 ;
70270   Dali::Image *argp2 ;
70271
70272   arg1 = (Dali::Toolkit::Button *)jarg1;
70273   argp2 = (Dali::Image *)jarg2;
70274   if (!argp2) {
70275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70276     return ;
70277   }
70278   arg2 = *argp2;
70279   {
70280     try {
70281       (arg1)->SetButtonImage(arg2);
70282     } catch (std::out_of_range& e) {
70283       {
70284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70285       };
70286     } catch (std::exception& e) {
70287       {
70288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70289       };
70290     } catch (Dali::DaliException e) {
70291       {
70292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70293       };
70294     } catch (...) {
70295       {
70296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70297       };
70298     }
70299   }
70300
70301 }
70302
70303
70304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70305   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70306   Dali::Image arg2 ;
70307   Dali::Image *argp2 ;
70308
70309   arg1 = (Dali::Toolkit::Button *)jarg1;
70310   argp2 = (Dali::Image *)jarg2;
70311   if (!argp2) {
70312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70313     return ;
70314   }
70315   arg2 = *argp2;
70316   {
70317     try {
70318       (arg1)->SetSelectedImage(arg2);
70319     } catch (std::out_of_range& e) {
70320       {
70321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70322       };
70323     } catch (std::exception& e) {
70324       {
70325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70326       };
70327     } catch (Dali::DaliException e) {
70328       {
70329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70330       };
70331     } catch (...) {
70332       {
70333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70334       };
70335     }
70336   }
70337
70338 }
70339
70340
70341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70342   void * jresult ;
70343   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70344   Dali::Actor result;
70345
70346   arg1 = (Dali::Toolkit::Button *)jarg1;
70347   {
70348     try {
70349       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70350     } catch (std::out_of_range& e) {
70351       {
70352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70353       };
70354     } catch (std::exception& e) {
70355       {
70356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70357       };
70358     } catch (Dali::DaliException e) {
70359       {
70360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70361       };
70362     } catch (...) {
70363       {
70364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70365       };
70366     }
70367   }
70368
70369   jresult = new Dali::Actor((const Dali::Actor &)result);
70370   return jresult;
70371 }
70372
70373
70374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70375   void * jresult ;
70376   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70377   Dali::Actor result;
70378
70379   arg1 = (Dali::Toolkit::Button *)jarg1;
70380   {
70381     try {
70382       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70383     } catch (std::out_of_range& e) {
70384       {
70385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70386       };
70387     } catch (std::exception& e) {
70388       {
70389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70390       };
70391     } catch (Dali::DaliException e) {
70392       {
70393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70394       };
70395     } catch (...) {
70396       {
70397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70398       };
70399     }
70400   }
70401
70402   jresult = new Dali::Actor((const Dali::Actor &)result);
70403   return jresult;
70404 }
70405
70406
70407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70408   void * jresult ;
70409   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70410   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70411
70412   arg1 = (Dali::Toolkit::Button *)jarg1;
70413   {
70414     try {
70415       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70416     } catch (std::out_of_range& e) {
70417       {
70418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70419       };
70420     } catch (std::exception& e) {
70421       {
70422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70423       };
70424     } catch (Dali::DaliException e) {
70425       {
70426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70427       };
70428     } catch (...) {
70429       {
70430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70431       };
70432     }
70433   }
70434
70435   jresult = (void *)result;
70436   return jresult;
70437 }
70438
70439
70440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70441   void * jresult ;
70442   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70443   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70444
70445   arg1 = (Dali::Toolkit::Button *)jarg1;
70446   {
70447     try {
70448       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70449     } catch (std::out_of_range& e) {
70450       {
70451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70452       };
70453     } catch (std::exception& e) {
70454       {
70455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70456       };
70457     } catch (Dali::DaliException e) {
70458       {
70459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70460       };
70461     } catch (...) {
70462       {
70463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70464       };
70465     }
70466   }
70467
70468   jresult = (void *)result;
70469   return jresult;
70470 }
70471
70472
70473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70474   void * jresult ;
70475   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70476   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70477
70478   arg1 = (Dali::Toolkit::Button *)jarg1;
70479   {
70480     try {
70481       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70482     } catch (std::out_of_range& e) {
70483       {
70484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70485       };
70486     } catch (std::exception& e) {
70487       {
70488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70489       };
70490     } catch (Dali::DaliException e) {
70491       {
70492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70493       };
70494     } catch (...) {
70495       {
70496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70497       };
70498     }
70499   }
70500
70501   jresult = (void *)result;
70502   return jresult;
70503 }
70504
70505
70506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70507   void * jresult ;
70508   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70509   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70510
70511   arg1 = (Dali::Toolkit::Button *)jarg1;
70512   {
70513     try {
70514       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70515     } catch (std::out_of_range& e) {
70516       {
70517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70518       };
70519     } catch (std::exception& e) {
70520       {
70521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70522       };
70523     } catch (Dali::DaliException e) {
70524       {
70525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70526       };
70527     } catch (...) {
70528       {
70529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70530       };
70531     }
70532   }
70533
70534   jresult = (void *)result;
70535   return jresult;
70536 }
70537
70538
70539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70540   void * jresult ;
70541   Dali::Toolkit::CheckBoxButton *result = 0 ;
70542
70543   {
70544     try {
70545       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70546     } catch (std::out_of_range& e) {
70547       {
70548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70549       };
70550     } catch (std::exception& e) {
70551       {
70552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70553       };
70554     } catch (Dali::DaliException e) {
70555       {
70556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70557       };
70558     } catch (...) {
70559       {
70560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70561       };
70562     }
70563   }
70564
70565   jresult = (void *)result;
70566   return jresult;
70567 }
70568
70569
70570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70571   void * jresult ;
70572   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70573   Dali::Toolkit::CheckBoxButton *result = 0 ;
70574
70575   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70576   if (!arg1) {
70577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70578     return 0;
70579   }
70580   {
70581     try {
70582       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70583     } catch (std::out_of_range& e) {
70584       {
70585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70586       };
70587     } catch (std::exception& e) {
70588       {
70589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70590       };
70591     } catch (Dali::DaliException e) {
70592       {
70593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70594       };
70595     } catch (...) {
70596       {
70597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70598       };
70599     }
70600   }
70601
70602   jresult = (void *)result;
70603   return jresult;
70604 }
70605
70606
70607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70608   void * jresult ;
70609   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70610   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70611   Dali::Toolkit::CheckBoxButton *result = 0 ;
70612
70613   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70614   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70615   if (!arg2) {
70616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70617     return 0;
70618   }
70619   {
70620     try {
70621       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70622     } catch (std::out_of_range& e) {
70623       {
70624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70625       };
70626     } catch (std::exception& e) {
70627       {
70628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70629       };
70630     } catch (Dali::DaliException e) {
70631       {
70632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70633       };
70634     } catch (...) {
70635       {
70636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70637       };
70638     }
70639   }
70640
70641   jresult = (void *)result;
70642   return jresult;
70643 }
70644
70645
70646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70647   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70648
70649   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70650   {
70651     try {
70652       delete arg1;
70653     } catch (std::out_of_range& e) {
70654       {
70655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70656       };
70657     } catch (std::exception& e) {
70658       {
70659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70660       };
70661     } catch (Dali::DaliException e) {
70662       {
70663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70664       };
70665     } catch (...) {
70666       {
70667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70668       };
70669     }
70670   }
70671
70672 }
70673
70674
70675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70676   void * jresult ;
70677   Dali::Toolkit::CheckBoxButton result;
70678
70679   {
70680     try {
70681       result = Dali::Toolkit::CheckBoxButton::New();
70682     } catch (std::out_of_range& e) {
70683       {
70684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70685       };
70686     } catch (std::exception& e) {
70687       {
70688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70689       };
70690     } catch (Dali::DaliException e) {
70691       {
70692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70693       };
70694     } catch (...) {
70695       {
70696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70697       };
70698     }
70699   }
70700
70701   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70702   return jresult;
70703 }
70704
70705
70706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70707   void * jresult ;
70708   Dali::BaseHandle arg1 ;
70709   Dali::BaseHandle *argp1 ;
70710   Dali::Toolkit::CheckBoxButton result;
70711
70712   argp1 = (Dali::BaseHandle *)jarg1;
70713   if (!argp1) {
70714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70715     return 0;
70716   }
70717   arg1 = *argp1;
70718   {
70719     try {
70720       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70721     } catch (std::out_of_range& e) {
70722       {
70723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70724       };
70725     } catch (std::exception& e) {
70726       {
70727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70728       };
70729     } catch (Dali::DaliException e) {
70730       {
70731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70732       };
70733     } catch (...) {
70734       {
70735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70736       };
70737     }
70738   }
70739
70740   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70741   return jresult;
70742 }
70743
70744
70745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70746   int jresult ;
70747   int result;
70748
70749   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70750   jresult = (int)result;
70751   return jresult;
70752 }
70753
70754
70755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70756   int jresult ;
70757   int result;
70758
70759   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70760   jresult = (int)result;
70761   return jresult;
70762 }
70763
70764
70765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70766   int jresult ;
70767   int result;
70768
70769   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70770   jresult = (int)result;
70771   return jresult;
70772 }
70773
70774
70775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70776   int jresult ;
70777   int result;
70778
70779   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70780   jresult = (int)result;
70781   return jresult;
70782 }
70783
70784
70785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70786   int jresult ;
70787   int result;
70788
70789   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70790   jresult = (int)result;
70791   return jresult;
70792 }
70793
70794
70795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70796   void * jresult ;
70797   Dali::Toolkit::PushButton::Property *result = 0 ;
70798
70799   {
70800     try {
70801       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70802     } catch (std::out_of_range& e) {
70803       {
70804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70805       };
70806     } catch (std::exception& e) {
70807       {
70808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70809       };
70810     } catch (Dali::DaliException e) {
70811       {
70812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70813       };
70814     } catch (...) {
70815       {
70816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70817       };
70818     }
70819   }
70820
70821   jresult = (void *)result;
70822   return jresult;
70823 }
70824
70825
70826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70827   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70828
70829   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70830   {
70831     try {
70832       delete arg1;
70833     } catch (std::out_of_range& e) {
70834       {
70835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70836       };
70837     } catch (std::exception& e) {
70838       {
70839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70840       };
70841     } catch (Dali::DaliException e) {
70842       {
70843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70844       };
70845     } catch (...) {
70846       {
70847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70848       };
70849     }
70850   }
70851
70852 }
70853
70854
70855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70856   void * jresult ;
70857   Dali::Toolkit::PushButton *result = 0 ;
70858
70859   {
70860     try {
70861       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70862     } catch (std::out_of_range& e) {
70863       {
70864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70865       };
70866     } catch (std::exception& e) {
70867       {
70868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70869       };
70870     } catch (Dali::DaliException e) {
70871       {
70872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70873       };
70874     } catch (...) {
70875       {
70876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70877       };
70878     }
70879   }
70880
70881   jresult = (void *)result;
70882   return jresult;
70883 }
70884
70885
70886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70887   void * jresult ;
70888   Dali::Toolkit::PushButton *arg1 = 0 ;
70889   Dali::Toolkit::PushButton *result = 0 ;
70890
70891   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70892   if (!arg1) {
70893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70894     return 0;
70895   }
70896   {
70897     try {
70898       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70899     } catch (std::out_of_range& e) {
70900       {
70901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70902       };
70903     } catch (std::exception& e) {
70904       {
70905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70906       };
70907     } catch (Dali::DaliException e) {
70908       {
70909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70910       };
70911     } catch (...) {
70912       {
70913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70914       };
70915     }
70916   }
70917
70918   jresult = (void *)result;
70919   return jresult;
70920 }
70921
70922
70923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70924   void * jresult ;
70925   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70926   Dali::Toolkit::PushButton *arg2 = 0 ;
70927   Dali::Toolkit::PushButton *result = 0 ;
70928
70929   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70930   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70931   if (!arg2) {
70932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70933     return 0;
70934   }
70935   {
70936     try {
70937       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70938     } catch (std::out_of_range& e) {
70939       {
70940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70941       };
70942     } catch (std::exception& e) {
70943       {
70944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70945       };
70946     } catch (Dali::DaliException e) {
70947       {
70948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70949       };
70950     } catch (...) {
70951       {
70952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70953       };
70954     }
70955   }
70956
70957   jresult = (void *)result;
70958   return jresult;
70959 }
70960
70961
70962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70963   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70964
70965   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70966   {
70967     try {
70968       delete arg1;
70969     } catch (std::out_of_range& e) {
70970       {
70971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70972       };
70973     } catch (std::exception& e) {
70974       {
70975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70976       };
70977     } catch (Dali::DaliException e) {
70978       {
70979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70980       };
70981     } catch (...) {
70982       {
70983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70984       };
70985     }
70986   }
70987
70988 }
70989
70990
70991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70992   void * jresult ;
70993   Dali::Toolkit::PushButton result;
70994
70995   {
70996     try {
70997       result = Dali::Toolkit::PushButton::New();
70998     } catch (std::out_of_range& e) {
70999       {
71000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71001       };
71002     } catch (std::exception& e) {
71003       {
71004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71005       };
71006     } catch (Dali::DaliException e) {
71007       {
71008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71009       };
71010     } catch (...) {
71011       {
71012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71013       };
71014     }
71015   }
71016
71017   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71018   return jresult;
71019 }
71020
71021
71022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
71023   void * jresult ;
71024   Dali::BaseHandle arg1 ;
71025   Dali::BaseHandle *argp1 ;
71026   Dali::Toolkit::PushButton result;
71027
71028   argp1 = (Dali::BaseHandle *)jarg1;
71029   if (!argp1) {
71030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71031     return 0;
71032   }
71033   arg1 = *argp1;
71034   {
71035     try {
71036       result = Dali::Toolkit::PushButton::DownCast(arg1);
71037     } catch (std::out_of_range& e) {
71038       {
71039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71040       };
71041     } catch (std::exception& e) {
71042       {
71043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71044       };
71045     } catch (Dali::DaliException e) {
71046       {
71047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71048       };
71049     } catch (...) {
71050       {
71051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71052       };
71053     }
71054   }
71055
71056   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71057   return jresult;
71058 }
71059
71060
71061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
71062   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71063   Dali::Image arg2 ;
71064   Dali::Image *argp2 ;
71065
71066   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71067   argp2 = (Dali::Image *)jarg2;
71068   if (!argp2) {
71069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71070     return ;
71071   }
71072   arg2 = *argp2;
71073   {
71074     try {
71075       (arg1)->SetButtonImage(arg2);
71076     } catch (std::out_of_range& e) {
71077       {
71078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71079       };
71080     } catch (std::exception& e) {
71081       {
71082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71083       };
71084     } catch (Dali::DaliException e) {
71085       {
71086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71087       };
71088     } catch (...) {
71089       {
71090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71091       };
71092     }
71093   }
71094
71095 }
71096
71097
71098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71099   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71100   Dali::Actor arg2 ;
71101   Dali::Actor *argp2 ;
71102
71103   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71104   argp2 = (Dali::Actor *)jarg2;
71105   if (!argp2) {
71106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71107     return ;
71108   }
71109   arg2 = *argp2;
71110   {
71111     try {
71112       (arg1)->SetButtonImage(arg2);
71113     } catch (std::out_of_range& e) {
71114       {
71115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71116       };
71117     } catch (std::exception& e) {
71118       {
71119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71120       };
71121     } catch (Dali::DaliException e) {
71122       {
71123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71124       };
71125     } catch (...) {
71126       {
71127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71128       };
71129     }
71130   }
71131
71132 }
71133
71134
71135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
71136   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71137   Dali::Actor arg2 ;
71138   Dali::Actor *argp2 ;
71139
71140   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71141   argp2 = (Dali::Actor *)jarg2;
71142   if (!argp2) {
71143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71144     return ;
71145   }
71146   arg2 = *argp2;
71147   {
71148     try {
71149       (arg1)->SetBackgroundImage(arg2);
71150     } catch (std::out_of_range& e) {
71151       {
71152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71153       };
71154     } catch (std::exception& e) {
71155       {
71156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71157       };
71158     } catch (Dali::DaliException e) {
71159       {
71160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71161       };
71162     } catch (...) {
71163       {
71164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71165       };
71166     }
71167   }
71168
71169 }
71170
71171
71172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71173   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71174   Dali::Image arg2 ;
71175   Dali::Image *argp2 ;
71176
71177   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71178   argp2 = (Dali::Image *)jarg2;
71179   if (!argp2) {
71180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71181     return ;
71182   }
71183   arg2 = *argp2;
71184   {
71185     try {
71186       (arg1)->SetSelectedImage(arg2);
71187     } catch (std::out_of_range& e) {
71188       {
71189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71190       };
71191     } catch (std::exception& e) {
71192       {
71193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71194       };
71195     } catch (Dali::DaliException e) {
71196       {
71197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71198       };
71199     } catch (...) {
71200       {
71201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71202       };
71203     }
71204   }
71205
71206 }
71207
71208
71209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
71210   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71211   Dali::Actor arg2 ;
71212   Dali::Actor *argp2 ;
71213
71214   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71215   argp2 = (Dali::Actor *)jarg2;
71216   if (!argp2) {
71217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71218     return ;
71219   }
71220   arg2 = *argp2;
71221   {
71222     try {
71223       (arg1)->SetSelectedImage(arg2);
71224     } catch (std::out_of_range& e) {
71225       {
71226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71227       };
71228     } catch (std::exception& e) {
71229       {
71230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71231       };
71232     } catch (Dali::DaliException e) {
71233       {
71234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71235       };
71236     } catch (...) {
71237       {
71238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71239       };
71240     }
71241   }
71242
71243 }
71244
71245
71246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71247   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71248   Dali::Actor arg2 ;
71249   Dali::Actor *argp2 ;
71250
71251   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71252   argp2 = (Dali::Actor *)jarg2;
71253   if (!argp2) {
71254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71255     return ;
71256   }
71257   arg2 = *argp2;
71258   {
71259     try {
71260       (arg1)->SetSelectedBackgroundImage(arg2);
71261     } catch (std::out_of_range& e) {
71262       {
71263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71264       };
71265     } catch (std::exception& e) {
71266       {
71267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71268       };
71269     } catch (Dali::DaliException e) {
71270       {
71271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71272       };
71273     } catch (...) {
71274       {
71275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71276       };
71277     }
71278   }
71279
71280 }
71281
71282
71283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71284   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71285   Dali::Actor arg2 ;
71286   Dali::Actor *argp2 ;
71287
71288   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71289   argp2 = (Dali::Actor *)jarg2;
71290   if (!argp2) {
71291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71292     return ;
71293   }
71294   arg2 = *argp2;
71295   {
71296     try {
71297       (arg1)->SetDisabledBackgroundImage(arg2);
71298     } catch (std::out_of_range& e) {
71299       {
71300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71301       };
71302     } catch (std::exception& e) {
71303       {
71304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71305       };
71306     } catch (Dali::DaliException e) {
71307       {
71308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71309       };
71310     } catch (...) {
71311       {
71312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71313       };
71314     }
71315   }
71316
71317 }
71318
71319
71320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71321   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71322   Dali::Actor arg2 ;
71323   Dali::Actor *argp2 ;
71324
71325   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71326   argp2 = (Dali::Actor *)jarg2;
71327   if (!argp2) {
71328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71329     return ;
71330   }
71331   arg2 = *argp2;
71332   {
71333     try {
71334       (arg1)->SetDisabledImage(arg2);
71335     } catch (std::out_of_range& e) {
71336       {
71337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71338       };
71339     } catch (std::exception& e) {
71340       {
71341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71342       };
71343     } catch (Dali::DaliException e) {
71344       {
71345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71346       };
71347     } catch (...) {
71348       {
71349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71350       };
71351     }
71352   }
71353
71354 }
71355
71356
71357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71358   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71359   Dali::Actor arg2 ;
71360   Dali::Actor *argp2 ;
71361
71362   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71363   argp2 = (Dali::Actor *)jarg2;
71364   if (!argp2) {
71365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71366     return ;
71367   }
71368   arg2 = *argp2;
71369   {
71370     try {
71371       (arg1)->SetDisabledSelectedImage(arg2);
71372     } catch (std::out_of_range& e) {
71373       {
71374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71375       };
71376     } catch (std::exception& e) {
71377       {
71378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71379       };
71380     } catch (Dali::DaliException e) {
71381       {
71382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71383       };
71384     } catch (...) {
71385       {
71386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71387       };
71388     }
71389   }
71390
71391 }
71392
71393
71394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71395   void * jresult ;
71396   Dali::Toolkit::RadioButton *result = 0 ;
71397
71398   {
71399     try {
71400       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71401     } catch (std::out_of_range& e) {
71402       {
71403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71404       };
71405     } catch (std::exception& e) {
71406       {
71407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71408       };
71409     } catch (Dali::DaliException e) {
71410       {
71411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71412       };
71413     } catch (...) {
71414       {
71415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71416       };
71417     }
71418   }
71419
71420   jresult = (void *)result;
71421   return jresult;
71422 }
71423
71424
71425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71426   void * jresult ;
71427   Dali::Toolkit::RadioButton *arg1 = 0 ;
71428   Dali::Toolkit::RadioButton *result = 0 ;
71429
71430   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71431   if (!arg1) {
71432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71433     return 0;
71434   }
71435   {
71436     try {
71437       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71438     } catch (std::out_of_range& e) {
71439       {
71440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71441       };
71442     } catch (std::exception& e) {
71443       {
71444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71445       };
71446     } catch (Dali::DaliException e) {
71447       {
71448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71449       };
71450     } catch (...) {
71451       {
71452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71453       };
71454     }
71455   }
71456
71457   jresult = (void *)result;
71458   return jresult;
71459 }
71460
71461
71462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71463   void * jresult ;
71464   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71465   Dali::Toolkit::RadioButton *arg2 = 0 ;
71466   Dali::Toolkit::RadioButton *result = 0 ;
71467
71468   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71469   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71470   if (!arg2) {
71471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71472     return 0;
71473   }
71474   {
71475     try {
71476       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71477     } catch (std::out_of_range& e) {
71478       {
71479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71480       };
71481     } catch (std::exception& e) {
71482       {
71483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71484       };
71485     } catch (Dali::DaliException e) {
71486       {
71487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71488       };
71489     } catch (...) {
71490       {
71491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71492       };
71493     }
71494   }
71495
71496   jresult = (void *)result;
71497   return jresult;
71498 }
71499
71500
71501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71502   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71503
71504   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71505   {
71506     try {
71507       delete arg1;
71508     } catch (std::out_of_range& e) {
71509       {
71510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71511       };
71512     } catch (std::exception& e) {
71513       {
71514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71515       };
71516     } catch (Dali::DaliException e) {
71517       {
71518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71519       };
71520     } catch (...) {
71521       {
71522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71523       };
71524     }
71525   }
71526
71527 }
71528
71529
71530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71531   void * jresult ;
71532   Dali::Toolkit::RadioButton result;
71533
71534   {
71535     try {
71536       result = Dali::Toolkit::RadioButton::New();
71537     } catch (std::out_of_range& e) {
71538       {
71539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71540       };
71541     } catch (std::exception& e) {
71542       {
71543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71544       };
71545     } catch (Dali::DaliException e) {
71546       {
71547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71548       };
71549     } catch (...) {
71550       {
71551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71552       };
71553     }
71554   }
71555
71556   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71557   return jresult;
71558 }
71559
71560
71561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71562   void * jresult ;
71563   std::string *arg1 = 0 ;
71564   Dali::Toolkit::RadioButton result;
71565
71566   if (!jarg1) {
71567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71568     return 0;
71569   }
71570   std::string arg1_str(jarg1);
71571   arg1 = &arg1_str;
71572   {
71573     try {
71574       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71575     } catch (std::out_of_range& e) {
71576       {
71577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71578       };
71579     } catch (std::exception& e) {
71580       {
71581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71582       };
71583     } catch (Dali::DaliException e) {
71584       {
71585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71586       };
71587     } catch (...) {
71588       {
71589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71590       };
71591     }
71592   }
71593
71594   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71595
71596   //argout typemap for const std::string&
71597
71598   return jresult;
71599 }
71600
71601
71602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71603   void * jresult ;
71604   Dali::BaseHandle arg1 ;
71605   Dali::BaseHandle *argp1 ;
71606   Dali::Toolkit::RadioButton result;
71607
71608   argp1 = (Dali::BaseHandle *)jarg1;
71609   if (!argp1) {
71610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71611     return 0;
71612   }
71613   arg1 = *argp1;
71614   {
71615     try {
71616       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71617     } catch (std::out_of_range& e) {
71618       {
71619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71620       };
71621     } catch (std::exception& e) {
71622       {
71623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71624       };
71625     } catch (Dali::DaliException e) {
71626       {
71627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71628       };
71629     } catch (...) {
71630       {
71631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71632       };
71633     }
71634   }
71635
71636   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71637   return jresult;
71638 }
71639
71640
71641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71642   int jresult ;
71643   int result;
71644
71645   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71646   jresult = (int)result;
71647   return jresult;
71648 }
71649
71650
71651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71652   int jresult ;
71653   int result;
71654
71655   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71656   jresult = (int)result;
71657   return jresult;
71658 }
71659
71660
71661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71662   int jresult ;
71663   int result;
71664
71665   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71666   jresult = (int)result;
71667   return jresult;
71668 }
71669
71670
71671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71672   int jresult ;
71673   int result;
71674
71675   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71676   jresult = (int)result;
71677   return jresult;
71678 }
71679
71680
71681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71682   int jresult ;
71683   int result;
71684
71685   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71686   jresult = (int)result;
71687   return jresult;
71688 }
71689
71690
71691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71692   int jresult ;
71693   int result;
71694
71695   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71696   jresult = (int)result;
71697   return jresult;
71698 }
71699
71700
71701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71702   void * jresult ;
71703   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71704
71705   {
71706     try {
71707       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71708     } catch (std::out_of_range& e) {
71709       {
71710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71711       };
71712     } catch (std::exception& e) {
71713       {
71714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71715       };
71716     } catch (Dali::DaliException e) {
71717       {
71718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71719       };
71720     } catch (...) {
71721       {
71722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71723       };
71724     }
71725   }
71726
71727   jresult = (void *)result;
71728   return jresult;
71729 }
71730
71731
71732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71733   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71734
71735   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71736   {
71737     try {
71738       delete arg1;
71739     } catch (std::out_of_range& e) {
71740       {
71741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71742       };
71743     } catch (std::exception& e) {
71744       {
71745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71746       };
71747     } catch (Dali::DaliException e) {
71748       {
71749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71750       };
71751     } catch (...) {
71752       {
71753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71754       };
71755     }
71756   }
71757
71758 }
71759
71760
71761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71762   int jresult ;
71763   int result;
71764
71765   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71766   jresult = (int)result;
71767   return jresult;
71768 }
71769
71770
71771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71772   int jresult ;
71773   int result;
71774
71775   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71776   jresult = (int)result;
71777   return jresult;
71778 }
71779
71780
71781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71782   int jresult ;
71783   int result;
71784
71785   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71786   jresult = (int)result;
71787   return jresult;
71788 }
71789
71790
71791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71792   void * jresult ;
71793   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71794
71795   {
71796     try {
71797       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71798     } catch (std::out_of_range& e) {
71799       {
71800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71801       };
71802     } catch (std::exception& e) {
71803       {
71804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71805       };
71806     } catch (Dali::DaliException e) {
71807       {
71808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71809       };
71810     } catch (...) {
71811       {
71812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71813       };
71814     }
71815   }
71816
71817   jresult = (void *)result;
71818   return jresult;
71819 }
71820
71821
71822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71823   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71824
71825   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71826   {
71827     try {
71828       delete arg1;
71829     } catch (std::out_of_range& e) {
71830       {
71831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71832       };
71833     } catch (std::exception& e) {
71834       {
71835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71836       };
71837     } catch (Dali::DaliException e) {
71838       {
71839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71840       };
71841     } catch (...) {
71842       {
71843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71844       };
71845     }
71846   }
71847
71848 }
71849
71850
71851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71852   void * jresult ;
71853   Dali::Toolkit::FlexContainer *result = 0 ;
71854
71855   {
71856     try {
71857       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71858     } catch (std::out_of_range& e) {
71859       {
71860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71861       };
71862     } catch (std::exception& e) {
71863       {
71864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71865       };
71866     } catch (Dali::DaliException e) {
71867       {
71868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71869       };
71870     } catch (...) {
71871       {
71872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71873       };
71874     }
71875   }
71876
71877   jresult = (void *)result;
71878   return jresult;
71879 }
71880
71881
71882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71883   void * jresult ;
71884   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71885   Dali::Toolkit::FlexContainer *result = 0 ;
71886
71887   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71888   if (!arg1) {
71889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71890     return 0;
71891   }
71892   {
71893     try {
71894       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71895     } catch (std::out_of_range& e) {
71896       {
71897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71898       };
71899     } catch (std::exception& e) {
71900       {
71901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71902       };
71903     } catch (Dali::DaliException e) {
71904       {
71905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71906       };
71907     } catch (...) {
71908       {
71909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71910       };
71911     }
71912   }
71913
71914   jresult = (void *)result;
71915   return jresult;
71916 }
71917
71918
71919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71920   void * jresult ;
71921   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71922   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71923   Dali::Toolkit::FlexContainer *result = 0 ;
71924
71925   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71926   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71927   if (!arg2) {
71928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71929     return 0;
71930   }
71931   {
71932     try {
71933       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71934     } catch (std::out_of_range& e) {
71935       {
71936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71937       };
71938     } catch (std::exception& e) {
71939       {
71940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71941       };
71942     } catch (Dali::DaliException e) {
71943       {
71944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71945       };
71946     } catch (...) {
71947       {
71948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71949       };
71950     }
71951   }
71952
71953   jresult = (void *)result;
71954   return jresult;
71955 }
71956
71957
71958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71959   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71960
71961   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71962   {
71963     try {
71964       delete arg1;
71965     } catch (std::out_of_range& e) {
71966       {
71967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71968       };
71969     } catch (std::exception& e) {
71970       {
71971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71972       };
71973     } catch (Dali::DaliException e) {
71974       {
71975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71976       };
71977     } catch (...) {
71978       {
71979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71980       };
71981     }
71982   }
71983
71984 }
71985
71986
71987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71988   void * jresult ;
71989   Dali::Toolkit::FlexContainer result;
71990
71991   {
71992     try {
71993       result = Dali::Toolkit::FlexContainer::New();
71994     } catch (std::out_of_range& e) {
71995       {
71996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71997       };
71998     } catch (std::exception& e) {
71999       {
72000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72001       };
72002     } catch (Dali::DaliException e) {
72003       {
72004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72005       };
72006     } catch (...) {
72007       {
72008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72009       };
72010     }
72011   }
72012
72013   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72014   return jresult;
72015 }
72016
72017
72018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
72019   void * jresult ;
72020   Dali::BaseHandle arg1 ;
72021   Dali::BaseHandle *argp1 ;
72022   Dali::Toolkit::FlexContainer result;
72023
72024   argp1 = (Dali::BaseHandle *)jarg1;
72025   if (!argp1) {
72026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72027     return 0;
72028   }
72029   arg1 = *argp1;
72030   {
72031     try {
72032       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
72033     } catch (std::out_of_range& e) {
72034       {
72035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72036       };
72037     } catch (std::exception& e) {
72038       {
72039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72040       };
72041     } catch (Dali::DaliException e) {
72042       {
72043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72044       };
72045     } catch (...) {
72046       {
72047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72048       };
72049     }
72050   }
72051
72052   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72053   return jresult;
72054 }
72055
72056
72057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
72058   int jresult ;
72059   int result;
72060
72061   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
72062   jresult = (int)result;
72063   return jresult;
72064 }
72065
72066
72067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
72068   int jresult ;
72069   int result;
72070
72071   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72072   jresult = (int)result;
72073   return jresult;
72074 }
72075
72076
72077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72078   int jresult ;
72079   int result;
72080
72081   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72082   jresult = (int)result;
72083   return jresult;
72084 }
72085
72086
72087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72088   int jresult ;
72089   int result;
72090
72091   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72092   jresult = (int)result;
72093   return jresult;
72094 }
72095
72096
72097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72098   void * jresult ;
72099   Dali::Toolkit::ImageView::Property *result = 0 ;
72100
72101   {
72102     try {
72103       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72104     } catch (std::out_of_range& e) {
72105       {
72106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72107       };
72108     } catch (std::exception& e) {
72109       {
72110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72111       };
72112     } catch (Dali::DaliException e) {
72113       {
72114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72115       };
72116     } catch (...) {
72117       {
72118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72119       };
72120     }
72121   }
72122
72123   jresult = (void *)result;
72124   return jresult;
72125 }
72126
72127
72128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72129   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72130
72131   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72132   {
72133     try {
72134       delete arg1;
72135     } catch (std::out_of_range& e) {
72136       {
72137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72138       };
72139     } catch (std::exception& e) {
72140       {
72141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72142       };
72143     } catch (Dali::DaliException e) {
72144       {
72145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72146       };
72147     } catch (...) {
72148       {
72149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72150       };
72151     }
72152   }
72153
72154 }
72155
72156
72157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72158   void * jresult ;
72159   Dali::Toolkit::ImageView *result = 0 ;
72160
72161   {
72162     try {
72163       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72164     } catch (std::out_of_range& e) {
72165       {
72166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72167       };
72168     } catch (std::exception& e) {
72169       {
72170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72171       };
72172     } catch (Dali::DaliException e) {
72173       {
72174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72175       };
72176     } catch (...) {
72177       {
72178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72179       };
72180     }
72181   }
72182
72183   jresult = (void *)result;
72184   return jresult;
72185 }
72186
72187
72188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72189   void * jresult ;
72190   Dali::Toolkit::ImageView result;
72191
72192   {
72193     try {
72194       result = Dali::Toolkit::ImageView::New();
72195     } catch (std::out_of_range& e) {
72196       {
72197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72198       };
72199     } catch (std::exception& e) {
72200       {
72201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72202       };
72203     } catch (Dali::DaliException e) {
72204       {
72205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72206       };
72207     } catch (...) {
72208       {
72209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72210       };
72211     }
72212   }
72213
72214   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72215   return jresult;
72216 }
72217
72218
72219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72220   void * jresult ;
72221   Dali::Image arg1 ;
72222   Dali::Image *argp1 ;
72223   Dali::Toolkit::ImageView result;
72224
72225   argp1 = (Dali::Image *)jarg1;
72226   if (!argp1) {
72227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72228     return 0;
72229   }
72230   arg1 = *argp1;
72231   {
72232     try {
72233       result = Dali::Toolkit::ImageView::New(arg1);
72234     } catch (std::out_of_range& e) {
72235       {
72236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72237       };
72238     } catch (std::exception& e) {
72239       {
72240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72241       };
72242     } catch (Dali::DaliException e) {
72243       {
72244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72245       };
72246     } catch (...) {
72247       {
72248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72249       };
72250     }
72251   }
72252
72253   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72254   return jresult;
72255 }
72256
72257
72258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72259   void * jresult ;
72260   std::string *arg1 = 0 ;
72261   Dali::Toolkit::ImageView result;
72262
72263   if (!jarg1) {
72264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72265     return 0;
72266   }
72267   std::string arg1_str(jarg1);
72268   arg1 = &arg1_str;
72269   {
72270     try {
72271       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72272     } catch (std::out_of_range& e) {
72273       {
72274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72275       };
72276     } catch (std::exception& e) {
72277       {
72278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72279       };
72280     } catch (Dali::DaliException e) {
72281       {
72282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72283       };
72284     } catch (...) {
72285       {
72286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72287       };
72288     }
72289   }
72290
72291   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72292
72293   //argout typemap for const std::string&
72294
72295   return jresult;
72296 }
72297
72298
72299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72300   void * jresult ;
72301   std::string *arg1 = 0 ;
72302   Dali::ImageDimensions arg2 ;
72303   Dali::ImageDimensions *argp2 ;
72304   Dali::Toolkit::ImageView result;
72305
72306   if (!jarg1) {
72307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72308     return 0;
72309   }
72310   std::string arg1_str(jarg1);
72311   arg1 = &arg1_str;
72312   argp2 = (Dali::ImageDimensions *)jarg2;
72313   if (!argp2) {
72314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72315     return 0;
72316   }
72317   arg2 = *argp2;
72318   {
72319     try {
72320       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72321     } catch (std::out_of_range& e) {
72322       {
72323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72324       };
72325     } catch (std::exception& e) {
72326       {
72327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72328       };
72329     } catch (Dali::DaliException e) {
72330       {
72331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72332       };
72333     } catch (...) {
72334       {
72335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72336       };
72337     }
72338   }
72339
72340   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72341
72342   //argout typemap for const std::string&
72343
72344   return jresult;
72345 }
72346
72347
72348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72349   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72350
72351   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72352   {
72353     try {
72354       delete arg1;
72355     } catch (std::out_of_range& e) {
72356       {
72357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72358       };
72359     } catch (std::exception& e) {
72360       {
72361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72362       };
72363     } catch (Dali::DaliException e) {
72364       {
72365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72366       };
72367     } catch (...) {
72368       {
72369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72370       };
72371     }
72372   }
72373
72374 }
72375
72376
72377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72378   void * jresult ;
72379   Dali::Toolkit::ImageView *arg1 = 0 ;
72380   Dali::Toolkit::ImageView *result = 0 ;
72381
72382   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72383   if (!arg1) {
72384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72385     return 0;
72386   }
72387   {
72388     try {
72389       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72390     } catch (std::out_of_range& e) {
72391       {
72392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72393       };
72394     } catch (std::exception& e) {
72395       {
72396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72397       };
72398     } catch (Dali::DaliException e) {
72399       {
72400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72401       };
72402     } catch (...) {
72403       {
72404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72405       };
72406     }
72407   }
72408
72409   jresult = (void *)result;
72410   return jresult;
72411 }
72412
72413
72414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72415   void * jresult ;
72416   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72417   Dali::Toolkit::ImageView *arg2 = 0 ;
72418   Dali::Toolkit::ImageView *result = 0 ;
72419
72420   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72421   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72422   if (!arg2) {
72423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72424     return 0;
72425   }
72426   {
72427     try {
72428       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72429     } catch (std::out_of_range& e) {
72430       {
72431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72432       };
72433     } catch (std::exception& e) {
72434       {
72435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72436       };
72437     } catch (Dali::DaliException e) {
72438       {
72439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72440       };
72441     } catch (...) {
72442       {
72443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72444       };
72445     }
72446   }
72447
72448   jresult = (void *)result;
72449   return jresult;
72450 }
72451
72452
72453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72454   void * jresult ;
72455   Dali::BaseHandle arg1 ;
72456   Dali::BaseHandle *argp1 ;
72457   Dali::Toolkit::ImageView result;
72458
72459   argp1 = (Dali::BaseHandle *)jarg1;
72460   if (!argp1) {
72461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72462     return 0;
72463   }
72464   arg1 = *argp1;
72465   {
72466     try {
72467       result = Dali::Toolkit::ImageView::DownCast(arg1);
72468     } catch (std::out_of_range& e) {
72469       {
72470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72471       };
72472     } catch (std::exception& e) {
72473       {
72474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72475       };
72476     } catch (Dali::DaliException e) {
72477       {
72478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72479       };
72480     } catch (...) {
72481       {
72482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72483       };
72484     }
72485   }
72486
72487   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72488   return jresult;
72489 }
72490
72491
72492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72493   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72494   Dali::Image arg2 ;
72495   Dali::Image *argp2 ;
72496
72497   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72498   argp2 = (Dali::Image *)jarg2;
72499   if (!argp2) {
72500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72501     return ;
72502   }
72503   arg2 = *argp2;
72504   {
72505     try {
72506       (arg1)->SetImage(arg2);
72507     } catch (std::out_of_range& e) {
72508       {
72509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72510       };
72511     } catch (std::exception& e) {
72512       {
72513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72514       };
72515     } catch (Dali::DaliException e) {
72516       {
72517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72518       };
72519     } catch (...) {
72520       {
72521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72522       };
72523     }
72524   }
72525
72526 }
72527
72528
72529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72530   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72531   std::string *arg2 = 0 ;
72532
72533   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72534   if (!jarg2) {
72535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72536     return ;
72537   }
72538   std::string arg2_str(jarg2);
72539   arg2 = &arg2_str;
72540   {
72541     try {
72542       (arg1)->SetImage((std::string const &)*arg2);
72543     } catch (std::out_of_range& e) {
72544       {
72545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72546       };
72547     } catch (std::exception& e) {
72548       {
72549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72550       };
72551     } catch (Dali::DaliException e) {
72552       {
72553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72554       };
72555     } catch (...) {
72556       {
72557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72558       };
72559     }
72560   }
72561
72562
72563   //argout typemap for const std::string&
72564
72565 }
72566
72567
72568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72569   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72570   std::string *arg2 = 0 ;
72571   Dali::ImageDimensions arg3 ;
72572   Dali::ImageDimensions *argp3 ;
72573
72574   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72575   if (!jarg2) {
72576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72577     return ;
72578   }
72579   std::string arg2_str(jarg2);
72580   arg2 = &arg2_str;
72581   argp3 = (Dali::ImageDimensions *)jarg3;
72582   if (!argp3) {
72583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72584     return ;
72585   }
72586   arg3 = *argp3;
72587   {
72588     try {
72589       (arg1)->SetImage((std::string const &)*arg2,arg3);
72590     } catch (std::out_of_range& e) {
72591       {
72592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72593       };
72594     } catch (std::exception& e) {
72595       {
72596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72597       };
72598     } catch (Dali::DaliException e) {
72599       {
72600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72601       };
72602     } catch (...) {
72603       {
72604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72605       };
72606     }
72607   }
72608
72609
72610   //argout typemap for const std::string&
72611
72612 }
72613
72614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72615   void * jresult ;
72616   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72617   Dali::Image result;
72618
72619   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72620   {
72621     try {
72622       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72623     } catch (std::out_of_range& e) {
72624       {
72625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72626       };
72627     } catch (std::exception& e) {
72628       {
72629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72630       };
72631     } catch (Dali::DaliException e) {
72632       {
72633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72634       };
72635     } catch (...) {
72636       {
72637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72638       };
72639     }
72640   }
72641
72642   jresult = new Dali::Image((const Dali::Image &)result);
72643   return jresult;
72644 }
72645
72646
72647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72648   int jresult ;
72649   int result;
72650
72651   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72652   jresult = (int)result;
72653   return jresult;
72654 }
72655
72656
72657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72658   int jresult ;
72659   int result;
72660
72661   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72662   jresult = (int)result;
72663   return jresult;
72664 }
72665
72666
72667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72668   int jresult ;
72669   int result;
72670
72671   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72672   jresult = (int)result;
72673   return jresult;
72674 }
72675
72676
72677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72678   int jresult ;
72679   int result;
72680
72681   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72682   jresult = (int)result;
72683   return jresult;
72684 }
72685
72686
72687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72688   int jresult ;
72689   int result;
72690
72691   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72692   jresult = (int)result;
72693   return jresult;
72694 }
72695
72696
72697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72698   int jresult ;
72699   int result;
72700
72701   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72702   jresult = (int)result;
72703   return jresult;
72704 }
72705
72706
72707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72708   int jresult ;
72709   int result;
72710
72711   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72712   jresult = (int)result;
72713   return jresult;
72714 }
72715
72716
72717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72718   int jresult ;
72719   int result;
72720
72721   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72722   jresult = (int)result;
72723   return jresult;
72724 }
72725
72726
72727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72728   void * jresult ;
72729   Dali::Toolkit::Model3dView::Property *result = 0 ;
72730
72731   {
72732     try {
72733       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72734     } catch (std::out_of_range& e) {
72735       {
72736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72737       };
72738     } catch (std::exception& e) {
72739       {
72740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72741       };
72742     } catch (Dali::DaliException e) {
72743       {
72744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72745       };
72746     } catch (...) {
72747       {
72748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72749       };
72750     }
72751   }
72752
72753   jresult = (void *)result;
72754   return jresult;
72755 }
72756
72757
72758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72759   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72760
72761   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72762   {
72763     try {
72764       delete arg1;
72765     } catch (std::out_of_range& e) {
72766       {
72767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72768       };
72769     } catch (std::exception& e) {
72770       {
72771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72772       };
72773     } catch (Dali::DaliException e) {
72774       {
72775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72776       };
72777     } catch (...) {
72778       {
72779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72780       };
72781     }
72782   }
72783
72784 }
72785
72786
72787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72788   void * jresult ;
72789   Dali::Toolkit::Model3dView result;
72790
72791   {
72792     try {
72793       result = Dali::Toolkit::Model3dView::New();
72794     } catch (std::out_of_range& e) {
72795       {
72796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72797       };
72798     } catch (std::exception& e) {
72799       {
72800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72801       };
72802     } catch (Dali::DaliException e) {
72803       {
72804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72805       };
72806     } catch (...) {
72807       {
72808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72809       };
72810     }
72811   }
72812
72813   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72814   return jresult;
72815 }
72816
72817
72818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72819   void * jresult ;
72820   std::string *arg1 = 0 ;
72821   std::string *arg2 = 0 ;
72822   std::string *arg3 = 0 ;
72823   Dali::Toolkit::Model3dView result;
72824
72825   if (!jarg1) {
72826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72827     return 0;
72828   }
72829   std::string arg1_str(jarg1);
72830   arg1 = &arg1_str;
72831   if (!jarg2) {
72832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72833     return 0;
72834   }
72835   std::string arg2_str(jarg2);
72836   arg2 = &arg2_str;
72837   if (!jarg3) {
72838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72839     return 0;
72840   }
72841   std::string arg3_str(jarg3);
72842   arg3 = &arg3_str;
72843   {
72844     try {
72845       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72846     } catch (std::out_of_range& e) {
72847       {
72848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72849       };
72850     } catch (std::exception& e) {
72851       {
72852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72853       };
72854     } catch (Dali::DaliException e) {
72855       {
72856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72857       };
72858     } catch (...) {
72859       {
72860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72861       };
72862     }
72863   }
72864
72865   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72866
72867   //argout typemap for const std::string&
72868
72869
72870   //argout typemap for const std::string&
72871
72872
72873   //argout typemap for const std::string&
72874
72875   return jresult;
72876 }
72877
72878
72879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72880   void * jresult ;
72881   Dali::Toolkit::Model3dView *result = 0 ;
72882
72883   {
72884     try {
72885       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72886     } catch (std::out_of_range& e) {
72887       {
72888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72889       };
72890     } catch (std::exception& e) {
72891       {
72892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72893       };
72894     } catch (Dali::DaliException e) {
72895       {
72896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72897       };
72898     } catch (...) {
72899       {
72900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72901       };
72902     }
72903   }
72904
72905   jresult = (void *)result;
72906   return jresult;
72907 }
72908
72909
72910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72911   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72912
72913   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72914   {
72915     try {
72916       delete arg1;
72917     } catch (std::out_of_range& e) {
72918       {
72919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72920       };
72921     } catch (std::exception& e) {
72922       {
72923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72924       };
72925     } catch (Dali::DaliException e) {
72926       {
72927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72928       };
72929     } catch (...) {
72930       {
72931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72932       };
72933     }
72934   }
72935
72936 }
72937
72938
72939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72940   void * jresult ;
72941   Dali::Toolkit::Model3dView *arg1 = 0 ;
72942   Dali::Toolkit::Model3dView *result = 0 ;
72943
72944   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72945   if (!arg1) {
72946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72947     return 0;
72948   }
72949   {
72950     try {
72951       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72952     } catch (std::out_of_range& e) {
72953       {
72954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72955       };
72956     } catch (std::exception& e) {
72957       {
72958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72959       };
72960     } catch (Dali::DaliException e) {
72961       {
72962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72963       };
72964     } catch (...) {
72965       {
72966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72967       };
72968     }
72969   }
72970
72971   jresult = (void *)result;
72972   return jresult;
72973 }
72974
72975
72976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72977   void * jresult ;
72978   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72979   Dali::Toolkit::Model3dView *arg2 = 0 ;
72980   Dali::Toolkit::Model3dView *result = 0 ;
72981
72982   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72983   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72984   if (!arg2) {
72985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72986     return 0;
72987   }
72988   {
72989     try {
72990       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72991     } catch (std::out_of_range& e) {
72992       {
72993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72994       };
72995     } catch (std::exception& e) {
72996       {
72997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72998       };
72999     } catch (Dali::DaliException e) {
73000       {
73001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73002       };
73003     } catch (...) {
73004       {
73005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73006       };
73007     }
73008   }
73009
73010   jresult = (void *)result;
73011   return jresult;
73012 }
73013
73014
73015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
73016   void * jresult ;
73017   Dali::BaseHandle arg1 ;
73018   Dali::BaseHandle *argp1 ;
73019   Dali::Toolkit::Model3dView result;
73020
73021   argp1 = (Dali::BaseHandle *)jarg1;
73022   if (!argp1) {
73023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73024     return 0;
73025   }
73026   arg1 = *argp1;
73027   {
73028     try {
73029       result = Dali::Toolkit::Model3dView::DownCast(arg1);
73030     } catch (std::out_of_range& e) {
73031       {
73032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73033       };
73034     } catch (std::exception& e) {
73035       {
73036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73037       };
73038     } catch (Dali::DaliException e) {
73039       {
73040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73041       };
73042     } catch (...) {
73043       {
73044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73045       };
73046     }
73047   }
73048
73049   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
73050   return jresult;
73051 }
73052
73053
73054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
73055   int jresult ;
73056   int result;
73057
73058   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
73059   jresult = (int)result;
73060   return jresult;
73061 }
73062
73063
73064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
73065   int jresult ;
73066   int result;
73067
73068   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
73069   jresult = (int)result;
73070   return jresult;
73071 }
73072
73073
73074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73075   int jresult ;
73076   int result;
73077
73078   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73079   jresult = (int)result;
73080   return jresult;
73081 }
73082
73083
73084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73085   int jresult ;
73086   int result;
73087
73088   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73089   jresult = (int)result;
73090   return jresult;
73091 }
73092
73093
73094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73095   int jresult ;
73096   int result;
73097
73098   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73099   jresult = (int)result;
73100   return jresult;
73101 }
73102
73103
73104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73105   int jresult ;
73106   int result;
73107
73108   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73109   jresult = (int)result;
73110   return jresult;
73111 }
73112
73113
73114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73115   int jresult ;
73116   int result;
73117
73118   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73119   jresult = (int)result;
73120   return jresult;
73121 }
73122
73123
73124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73125   int jresult ;
73126   int result;
73127
73128   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73129   jresult = (int)result;
73130   return jresult;
73131 }
73132
73133
73134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73135   int jresult ;
73136   int result;
73137
73138   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73139   jresult = (int)result;
73140   return jresult;
73141 }
73142
73143
73144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73145   void * jresult ;
73146   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73147
73148   {
73149     try {
73150       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73151     } catch (std::out_of_range& e) {
73152       {
73153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73154       };
73155     } catch (std::exception& e) {
73156       {
73157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73158       };
73159     } catch (Dali::DaliException e) {
73160       {
73161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73162       };
73163     } catch (...) {
73164       {
73165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73166       };
73167     }
73168   }
73169
73170   jresult = (void *)result;
73171   return jresult;
73172 }
73173
73174
73175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73176   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73177
73178   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73179   {
73180     try {
73181       delete arg1;
73182     } catch (std::out_of_range& e) {
73183       {
73184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73185       };
73186     } catch (std::exception& e) {
73187       {
73188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73189       };
73190     } catch (Dali::DaliException e) {
73191       {
73192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73193       };
73194     } catch (...) {
73195       {
73196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73197       };
73198     }
73199   }
73200
73201 }
73202
73203
73204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73205   void * jresult ;
73206   Dali::Toolkit::ScrollBar *result = 0 ;
73207
73208   {
73209     try {
73210       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73211     } catch (std::out_of_range& e) {
73212       {
73213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73214       };
73215     } catch (std::exception& e) {
73216       {
73217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73218       };
73219     } catch (Dali::DaliException e) {
73220       {
73221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73222       };
73223     } catch (...) {
73224       {
73225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73226       };
73227     }
73228   }
73229
73230   jresult = (void *)result;
73231   return jresult;
73232 }
73233
73234
73235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73236   void * jresult ;
73237   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73238   Dali::Toolkit::ScrollBar *result = 0 ;
73239
73240   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73241   if (!arg1) {
73242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73243     return 0;
73244   }
73245   {
73246     try {
73247       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73248     } catch (std::out_of_range& e) {
73249       {
73250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73251       };
73252     } catch (std::exception& e) {
73253       {
73254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73255       };
73256     } catch (Dali::DaliException e) {
73257       {
73258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73259       };
73260     } catch (...) {
73261       {
73262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73263       };
73264     }
73265   }
73266
73267   jresult = (void *)result;
73268   return jresult;
73269 }
73270
73271
73272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73273   void * jresult ;
73274   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73275   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73276   Dali::Toolkit::ScrollBar *result = 0 ;
73277
73278   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73279   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73280   if (!arg2) {
73281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73282     return 0;
73283   }
73284   {
73285     try {
73286       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73287     } catch (std::out_of_range& e) {
73288       {
73289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73290       };
73291     } catch (std::exception& e) {
73292       {
73293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73294       };
73295     } catch (Dali::DaliException e) {
73296       {
73297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73298       };
73299     } catch (...) {
73300       {
73301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73302       };
73303     }
73304   }
73305
73306   jresult = (void *)result;
73307   return jresult;
73308 }
73309
73310
73311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73312   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73313
73314   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73315   {
73316     try {
73317       delete arg1;
73318     } catch (std::out_of_range& e) {
73319       {
73320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73321       };
73322     } catch (std::exception& e) {
73323       {
73324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73325       };
73326     } catch (Dali::DaliException e) {
73327       {
73328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73329       };
73330     } catch (...) {
73331       {
73332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73333       };
73334     }
73335   }
73336
73337 }
73338
73339
73340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73341   void * jresult ;
73342   Dali::Toolkit::ScrollBar::Direction arg1 ;
73343   Dali::Toolkit::ScrollBar result;
73344
73345   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73346   {
73347     try {
73348       result = Dali::Toolkit::ScrollBar::New(arg1);
73349     } catch (std::out_of_range& e) {
73350       {
73351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73352       };
73353     } catch (std::exception& e) {
73354       {
73355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73356       };
73357     } catch (Dali::DaliException e) {
73358       {
73359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73360       };
73361     } catch (...) {
73362       {
73363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73364       };
73365     }
73366   }
73367
73368   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73369   return jresult;
73370 }
73371
73372
73373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73374   void * jresult ;
73375   Dali::Toolkit::ScrollBar result;
73376
73377   {
73378     try {
73379       result = Dali::Toolkit::ScrollBar::New();
73380     } catch (std::out_of_range& e) {
73381       {
73382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73383       };
73384     } catch (std::exception& e) {
73385       {
73386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73387       };
73388     } catch (Dali::DaliException e) {
73389       {
73390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73391       };
73392     } catch (...) {
73393       {
73394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73395       };
73396     }
73397   }
73398
73399   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73400   return jresult;
73401 }
73402
73403
73404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73405   void * jresult ;
73406   Dali::BaseHandle arg1 ;
73407   Dali::BaseHandle *argp1 ;
73408   Dali::Toolkit::ScrollBar result;
73409
73410   argp1 = (Dali::BaseHandle *)jarg1;
73411   if (!argp1) {
73412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73413     return 0;
73414   }
73415   arg1 = *argp1;
73416   {
73417     try {
73418       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73419     } catch (std::out_of_range& e) {
73420       {
73421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73422       };
73423     } catch (std::exception& e) {
73424       {
73425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73426       };
73427     } catch (Dali::DaliException e) {
73428       {
73429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73430       };
73431     } catch (...) {
73432       {
73433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73434       };
73435     }
73436   }
73437
73438   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73439   return jresult;
73440 }
73441
73442
73443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73444   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73445   Dali::Handle arg2 ;
73446   Dali::Property::Index arg3 ;
73447   Dali::Property::Index arg4 ;
73448   Dali::Property::Index arg5 ;
73449   Dali::Property::Index arg6 ;
73450   Dali::Handle *argp2 ;
73451
73452   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73453   argp2 = (Dali::Handle *)jarg2;
73454   if (!argp2) {
73455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73456     return ;
73457   }
73458   arg2 = *argp2;
73459   arg3 = (Dali::Property::Index)jarg3;
73460   arg4 = (Dali::Property::Index)jarg4;
73461   arg5 = (Dali::Property::Index)jarg5;
73462   arg6 = (Dali::Property::Index)jarg6;
73463   {
73464     try {
73465       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73466     } catch (std::out_of_range& e) {
73467       {
73468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73469       };
73470     } catch (std::exception& e) {
73471       {
73472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73473       };
73474     } catch (Dali::DaliException e) {
73475       {
73476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73477       };
73478     } catch (...) {
73479       {
73480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73481       };
73482     }
73483   }
73484
73485 }
73486
73487
73488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73489   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73490   Dali::Actor arg2 ;
73491   Dali::Actor *argp2 ;
73492
73493   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73494   argp2 = (Dali::Actor *)jarg2;
73495   if (!argp2) {
73496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73497     return ;
73498   }
73499   arg2 = *argp2;
73500   {
73501     try {
73502       (arg1)->SetScrollIndicator(arg2);
73503     } catch (std::out_of_range& e) {
73504       {
73505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73506       };
73507     } catch (std::exception& e) {
73508       {
73509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73510       };
73511     } catch (Dali::DaliException e) {
73512       {
73513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73514       };
73515     } catch (...) {
73516       {
73517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73518       };
73519     }
73520   }
73521
73522 }
73523
73524
73525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73526   void * jresult ;
73527   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73528   Dali::Actor result;
73529
73530   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73531   {
73532     try {
73533       result = (arg1)->GetScrollIndicator();
73534     } catch (std::out_of_range& e) {
73535       {
73536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73537       };
73538     } catch (std::exception& e) {
73539       {
73540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73541       };
73542     } catch (Dali::DaliException e) {
73543       {
73544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73545       };
73546     } catch (...) {
73547       {
73548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73549       };
73550     }
73551   }
73552
73553   jresult = new Dali::Actor((const Dali::Actor &)result);
73554   return jresult;
73555 }
73556
73557
73558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73559   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73560   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73561
73562   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73563   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73564   if (!arg2) {
73565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73566     return ;
73567   }
73568   {
73569     try {
73570       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73571     } catch (std::out_of_range& e) {
73572       {
73573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73574       };
73575     } catch (std::exception& e) {
73576       {
73577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73578       };
73579     } catch (Dali::DaliException e) {
73580       {
73581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73582       };
73583     } catch (...) {
73584       {
73585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73586       };
73587     }
73588   }
73589
73590 }
73591
73592
73593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73594   void * jresult ;
73595   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73596
73597   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73598   {
73599     try {
73600       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()));
73601     } catch (std::out_of_range& e) {
73602       {
73603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73604       };
73605     } catch (std::exception& e) {
73606       {
73607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73608       };
73609     } catch (...) {
73610       {
73611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73612       };
73613     }
73614   }
73615   return jresult;
73616 }
73617
73618
73619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73620   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73621   Dali::Toolkit::ScrollBar::Direction arg2 ;
73622
73623   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73624   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73625   {
73626     try {
73627       (arg1)->SetScrollDirection(arg2);
73628     } catch (std::out_of_range& e) {
73629       {
73630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73631       };
73632     } catch (std::exception& e) {
73633       {
73634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73635       };
73636     } catch (Dali::DaliException e) {
73637       {
73638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73639       };
73640     } catch (...) {
73641       {
73642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73643       };
73644     }
73645   }
73646
73647 }
73648
73649
73650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73651   int jresult ;
73652   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73653   Dali::Toolkit::ScrollBar::Direction result;
73654
73655   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73656   {
73657     try {
73658       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73659     } catch (std::out_of_range& e) {
73660       {
73661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73662       };
73663     } catch (std::exception& e) {
73664       {
73665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73666       };
73667     } catch (Dali::DaliException e) {
73668       {
73669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73670       };
73671     } catch (...) {
73672       {
73673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73674       };
73675     }
73676   }
73677
73678   jresult = (int)result;
73679   return jresult;
73680 }
73681
73682
73683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73684   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73685   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73686
73687   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73688   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73689   {
73690     try {
73691       (arg1)->SetIndicatorHeightPolicy(arg2);
73692     } catch (std::out_of_range& e) {
73693       {
73694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73695       };
73696     } catch (std::exception& e) {
73697       {
73698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73699       };
73700     } catch (Dali::DaliException e) {
73701       {
73702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73703       };
73704     } catch (...) {
73705       {
73706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73707       };
73708     }
73709   }
73710
73711 }
73712
73713
73714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73715   int jresult ;
73716   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73717   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73718
73719   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73720   {
73721     try {
73722       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73723     } catch (std::out_of_range& e) {
73724       {
73725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73726       };
73727     } catch (std::exception& e) {
73728       {
73729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73730       };
73731     } catch (Dali::DaliException e) {
73732       {
73733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73734       };
73735     } catch (...) {
73736       {
73737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73738       };
73739     }
73740   }
73741
73742   jresult = (int)result;
73743   return jresult;
73744 }
73745
73746
73747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73748   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73749   float arg2 ;
73750
73751   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73752   arg2 = (float)jarg2;
73753   {
73754     try {
73755       (arg1)->SetIndicatorFixedHeight(arg2);
73756     } catch (std::out_of_range& e) {
73757       {
73758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73759       };
73760     } catch (std::exception& e) {
73761       {
73762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73763       };
73764     } catch (Dali::DaliException e) {
73765       {
73766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73767       };
73768     } catch (...) {
73769       {
73770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73771       };
73772     }
73773   }
73774
73775 }
73776
73777
73778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73779   float jresult ;
73780   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73781   float result;
73782
73783   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73784   {
73785     try {
73786       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73787     } catch (std::out_of_range& e) {
73788       {
73789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73790       };
73791     } catch (std::exception& e) {
73792       {
73793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73794       };
73795     } catch (Dali::DaliException e) {
73796       {
73797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73798       };
73799     } catch (...) {
73800       {
73801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73802       };
73803     }
73804   }
73805
73806   jresult = result;
73807   return jresult;
73808 }
73809
73810
73811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73812   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73813   float arg2 ;
73814
73815   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73816   arg2 = (float)jarg2;
73817   {
73818     try {
73819       (arg1)->SetIndicatorShowDuration(arg2);
73820     } catch (std::out_of_range& e) {
73821       {
73822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73823       };
73824     } catch (std::exception& e) {
73825       {
73826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73827       };
73828     } catch (Dali::DaliException e) {
73829       {
73830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73831       };
73832     } catch (...) {
73833       {
73834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73835       };
73836     }
73837   }
73838
73839 }
73840
73841
73842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73843   float jresult ;
73844   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73845   float result;
73846
73847   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73848   {
73849     try {
73850       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73851     } catch (std::out_of_range& e) {
73852       {
73853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73854       };
73855     } catch (std::exception& e) {
73856       {
73857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73858       };
73859     } catch (Dali::DaliException e) {
73860       {
73861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73862       };
73863     } catch (...) {
73864       {
73865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73866       };
73867     }
73868   }
73869
73870   jresult = result;
73871   return jresult;
73872 }
73873
73874
73875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73876   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73877   float arg2 ;
73878
73879   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73880   arg2 = (float)jarg2;
73881   {
73882     try {
73883       (arg1)->SetIndicatorHideDuration(arg2);
73884     } catch (std::out_of_range& e) {
73885       {
73886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73887       };
73888     } catch (std::exception& e) {
73889       {
73890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73891       };
73892     } catch (Dali::DaliException e) {
73893       {
73894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73895       };
73896     } catch (...) {
73897       {
73898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73899       };
73900     }
73901   }
73902
73903 }
73904
73905
73906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73907   float jresult ;
73908   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73909   float result;
73910
73911   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73912   {
73913     try {
73914       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73915     } catch (std::out_of_range& e) {
73916       {
73917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73918       };
73919     } catch (std::exception& e) {
73920       {
73921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73922       };
73923     } catch (Dali::DaliException e) {
73924       {
73925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73926       };
73927     } catch (...) {
73928       {
73929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73930       };
73931     }
73932   }
73933
73934   jresult = result;
73935   return jresult;
73936 }
73937
73938
73939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73940   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73941
73942   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73943   {
73944     try {
73945       (arg1)->ShowIndicator();
73946     } catch (std::out_of_range& e) {
73947       {
73948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73949       };
73950     } catch (std::exception& e) {
73951       {
73952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73953       };
73954     } catch (Dali::DaliException e) {
73955       {
73956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73957       };
73958     } catch (...) {
73959       {
73960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73961       };
73962     }
73963   }
73964
73965 }
73966
73967
73968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73969   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73970
73971   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73972   {
73973     try {
73974       (arg1)->HideIndicator();
73975     } catch (std::out_of_range& e) {
73976       {
73977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73978       };
73979     } catch (std::exception& e) {
73980       {
73981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73982       };
73983     } catch (Dali::DaliException e) {
73984       {
73985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73986       };
73987     } catch (...) {
73988       {
73989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73990       };
73991     }
73992   }
73993
73994 }
73995
73996
73997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73998   void * jresult ;
73999   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74000   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
74001
74002   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74003   {
74004     try {
74005       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
74006     } catch (std::out_of_range& e) {
74007       {
74008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74009       };
74010     } catch (std::exception& e) {
74011       {
74012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74013       };
74014     } catch (Dali::DaliException e) {
74015       {
74016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74017       };
74018     } catch (...) {
74019       {
74020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74021       };
74022     }
74023   }
74024
74025   jresult = (void *)result;
74026   return jresult;
74027 }
74028
74029
74030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
74031   void * jresult ;
74032   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74033   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
74034
74035   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74036   {
74037     try {
74038       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
74039     } catch (std::out_of_range& e) {
74040       {
74041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74042       };
74043     } catch (std::exception& e) {
74044       {
74045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74046       };
74047     } catch (Dali::DaliException e) {
74048       {
74049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74050       };
74051     } catch (...) {
74052       {
74053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74054       };
74055     }
74056   }
74057
74058   jresult = (void *)result;
74059   return jresult;
74060 }
74061
74062
74063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
74064   int jresult ;
74065   int result;
74066
74067   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
74068   jresult = (int)result;
74069   return jresult;
74070 }
74071
74072
74073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74074   int jresult ;
74075   int result;
74076
74077   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74078   jresult = (int)result;
74079   return jresult;
74080 }
74081
74082
74083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74084   int jresult ;
74085   int result;
74086
74087   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74088   jresult = (int)result;
74089   return jresult;
74090 }
74091
74092
74093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74094   int jresult ;
74095   int result;
74096
74097   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74098   jresult = (int)result;
74099   return jresult;
74100 }
74101
74102
74103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74104   int jresult ;
74105   int result;
74106
74107   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74108   jresult = (int)result;
74109   return jresult;
74110 }
74111
74112
74113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74114   int jresult ;
74115   int result;
74116
74117   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74118   jresult = (int)result;
74119   return jresult;
74120 }
74121
74122
74123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74124   int jresult ;
74125   int result;
74126
74127   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74128   jresult = (int)result;
74129   return jresult;
74130 }
74131
74132
74133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74134   int jresult ;
74135   int result;
74136
74137   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74138   jresult = (int)result;
74139   return jresult;
74140 }
74141
74142
74143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74144   int jresult ;
74145   int result;
74146
74147   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74148   jresult = (int)result;
74149   return jresult;
74150 }
74151
74152
74153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74154   int jresult ;
74155   int result;
74156
74157   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74158   jresult = (int)result;
74159   return jresult;
74160 }
74161
74162
74163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74164   int jresult ;
74165   int result;
74166
74167   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74168   jresult = (int)result;
74169   return jresult;
74170 }
74171
74172
74173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74174   int jresult ;
74175   int result;
74176
74177   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74178   jresult = (int)result;
74179   return jresult;
74180 }
74181
74182
74183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74184   int jresult ;
74185   int result;
74186
74187   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74188   jresult = (int)result;
74189   return jresult;
74190 }
74191
74192
74193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74194   int jresult ;
74195   int result;
74196
74197   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74198   jresult = (int)result;
74199   return jresult;
74200 }
74201
74202
74203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74204   void * jresult ;
74205   Dali::Toolkit::Scrollable::Property *result = 0 ;
74206
74207   {
74208     try {
74209       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
74210     } catch (std::out_of_range& e) {
74211       {
74212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74213       };
74214     } catch (std::exception& e) {
74215       {
74216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74217       };
74218     } catch (Dali::DaliException e) {
74219       {
74220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74221       };
74222     } catch (...) {
74223       {
74224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74225       };
74226     }
74227   }
74228
74229   jresult = (void *)result;
74230   return jresult;
74231 }
74232
74233
74234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74235   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74236
74237   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74238   {
74239     try {
74240       delete arg1;
74241     } catch (std::out_of_range& e) {
74242       {
74243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74244       };
74245     } catch (std::exception& e) {
74246       {
74247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74248       };
74249     } catch (Dali::DaliException e) {
74250       {
74251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74252       };
74253     } catch (...) {
74254       {
74255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74256       };
74257     }
74258   }
74259
74260 }
74261
74262
74263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74264   void * jresult ;
74265   Dali::Toolkit::Scrollable *result = 0 ;
74266
74267   {
74268     try {
74269       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74270     } catch (std::out_of_range& e) {
74271       {
74272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74273       };
74274     } catch (std::exception& e) {
74275       {
74276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74277       };
74278     } catch (Dali::DaliException e) {
74279       {
74280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74281       };
74282     } catch (...) {
74283       {
74284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74285       };
74286     }
74287   }
74288
74289   jresult = (void *)result;
74290   return jresult;
74291 }
74292
74293
74294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74295   void * jresult ;
74296   Dali::Toolkit::Scrollable *arg1 = 0 ;
74297   Dali::Toolkit::Scrollable *result = 0 ;
74298
74299   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74300   if (!arg1) {
74301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74302     return 0;
74303   }
74304   {
74305     try {
74306       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74307     } catch (std::out_of_range& e) {
74308       {
74309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74310       };
74311     } catch (std::exception& e) {
74312       {
74313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74314       };
74315     } catch (Dali::DaliException e) {
74316       {
74317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74318       };
74319     } catch (...) {
74320       {
74321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74322       };
74323     }
74324   }
74325
74326   jresult = (void *)result;
74327   return jresult;
74328 }
74329
74330
74331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74332   void * jresult ;
74333   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74334   Dali::Toolkit::Scrollable *arg2 = 0 ;
74335   Dali::Toolkit::Scrollable *result = 0 ;
74336
74337   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74338   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74339   if (!arg2) {
74340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74341     return 0;
74342   }
74343   {
74344     try {
74345       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74346     } catch (std::out_of_range& e) {
74347       {
74348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74349       };
74350     } catch (std::exception& e) {
74351       {
74352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74353       };
74354     } catch (Dali::DaliException e) {
74355       {
74356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74357       };
74358     } catch (...) {
74359       {
74360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74361       };
74362     }
74363   }
74364
74365   jresult = (void *)result;
74366   return jresult;
74367 }
74368
74369
74370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74371   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74372
74373   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74374   {
74375     try {
74376       delete arg1;
74377     } catch (std::out_of_range& e) {
74378       {
74379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74380       };
74381     } catch (std::exception& e) {
74382       {
74383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74384       };
74385     } catch (Dali::DaliException e) {
74386       {
74387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74388       };
74389     } catch (...) {
74390       {
74391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74392       };
74393     }
74394   }
74395
74396 }
74397
74398
74399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74400   void * jresult ;
74401   Dali::BaseHandle arg1 ;
74402   Dali::BaseHandle *argp1 ;
74403   Dali::Toolkit::Scrollable result;
74404
74405   argp1 = (Dali::BaseHandle *)jarg1;
74406   if (!argp1) {
74407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74408     return 0;
74409   }
74410   arg1 = *argp1;
74411   {
74412     try {
74413       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74414     } catch (std::out_of_range& e) {
74415       {
74416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74417       };
74418     } catch (std::exception& e) {
74419       {
74420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74421       };
74422     } catch (Dali::DaliException e) {
74423       {
74424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74425       };
74426     } catch (...) {
74427       {
74428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74429       };
74430     }
74431   }
74432
74433   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74434   return jresult;
74435 }
74436
74437
74438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74439   unsigned int jresult ;
74440   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74441   bool result;
74442
74443   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74444   {
74445     try {
74446       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74447     } catch (std::out_of_range& e) {
74448       {
74449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74450       };
74451     } catch (std::exception& e) {
74452       {
74453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74454       };
74455     } catch (Dali::DaliException e) {
74456       {
74457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74458       };
74459     } catch (...) {
74460       {
74461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74462       };
74463     }
74464   }
74465
74466   jresult = result;
74467   return jresult;
74468 }
74469
74470
74471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74472   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74473   bool arg2 ;
74474
74475   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74476   arg2 = jarg2 ? true : false;
74477   {
74478     try {
74479       (arg1)->SetOvershootEnabled(arg2);
74480     } catch (std::out_of_range& e) {
74481       {
74482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74483       };
74484     } catch (std::exception& e) {
74485       {
74486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74487       };
74488     } catch (Dali::DaliException e) {
74489       {
74490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74491       };
74492     } catch (...) {
74493       {
74494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74495       };
74496     }
74497   }
74498
74499 }
74500
74501
74502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74503   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74504   Dali::Vector4 *arg2 = 0 ;
74505
74506   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74507   arg2 = (Dali::Vector4 *)jarg2;
74508   if (!arg2) {
74509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74510     return ;
74511   }
74512   {
74513     try {
74514       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74515     } catch (std::out_of_range& e) {
74516       {
74517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74518       };
74519     } catch (std::exception& e) {
74520       {
74521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74522       };
74523     } catch (Dali::DaliException e) {
74524       {
74525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74526       };
74527     } catch (...) {
74528       {
74529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74530       };
74531     }
74532   }
74533
74534 }
74535
74536
74537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74538   void * jresult ;
74539   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74540   Dali::Vector4 result;
74541
74542   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74543   {
74544     try {
74545       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74546     } catch (std::out_of_range& e) {
74547       {
74548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74549       };
74550     } catch (std::exception& e) {
74551       {
74552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74553       };
74554     } catch (Dali::DaliException e) {
74555       {
74556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74557       };
74558     } catch (...) {
74559       {
74560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74561       };
74562     }
74563   }
74564
74565   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74566   return jresult;
74567 }
74568
74569
74570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74571   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74572   float arg2 ;
74573
74574   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74575   arg2 = (float)jarg2;
74576   {
74577     try {
74578       (arg1)->SetOvershootAnimationSpeed(arg2);
74579     } catch (std::out_of_range& e) {
74580       {
74581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74582       };
74583     } catch (std::exception& e) {
74584       {
74585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74586       };
74587     } catch (Dali::DaliException e) {
74588       {
74589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74590       };
74591     } catch (...) {
74592       {
74593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74594       };
74595     }
74596   }
74597
74598 }
74599
74600
74601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74602   float jresult ;
74603   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74604   float result;
74605
74606   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74607   {
74608     try {
74609       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74610     } catch (std::out_of_range& e) {
74611       {
74612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74613       };
74614     } catch (std::exception& e) {
74615       {
74616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74617       };
74618     } catch (Dali::DaliException e) {
74619       {
74620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74621       };
74622     } catch (...) {
74623       {
74624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74625       };
74626     }
74627   }
74628
74629   jresult = result;
74630   return jresult;
74631 }
74632
74633
74634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74635   void * jresult ;
74636   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74637   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74638
74639   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74640   {
74641     try {
74642       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74643     } catch (std::out_of_range& e) {
74644       {
74645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74646       };
74647     } catch (std::exception& e) {
74648       {
74649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74650       };
74651     } catch (Dali::DaliException e) {
74652       {
74653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74654       };
74655     } catch (...) {
74656       {
74657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74658       };
74659     }
74660   }
74661
74662   jresult = (void *)result;
74663   return jresult;
74664 }
74665
74666
74667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74668   void * jresult ;
74669   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74670   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74671
74672   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74673   {
74674     try {
74675       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74676     } catch (std::out_of_range& e) {
74677       {
74678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74679       };
74680     } catch (std::exception& e) {
74681       {
74682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74683       };
74684     } catch (Dali::DaliException e) {
74685       {
74686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74687       };
74688     } catch (...) {
74689       {
74690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74691       };
74692     }
74693   }
74694
74695   jresult = (void *)result;
74696   return jresult;
74697 }
74698
74699
74700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74701   void * jresult ;
74702   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74703   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74704
74705   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74706   {
74707     try {
74708       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74709     } catch (std::out_of_range& e) {
74710       {
74711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74712       };
74713     } catch (std::exception& e) {
74714       {
74715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74716       };
74717     } catch (Dali::DaliException e) {
74718       {
74719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74720       };
74721     } catch (...) {
74722       {
74723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74724       };
74725     }
74726   }
74727
74728   jresult = (void *)result;
74729   return jresult;
74730 }
74731
74732
74733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74734   unsigned int jresult ;
74735   Dali::Toolkit::ControlOrientation::Type arg1 ;
74736   bool result;
74737
74738   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74739   {
74740     try {
74741       result = (bool)Dali::Toolkit::IsVertical(arg1);
74742     } catch (std::out_of_range& e) {
74743       {
74744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74745       };
74746     } catch (std::exception& e) {
74747       {
74748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74749       };
74750     } catch (Dali::DaliException e) {
74751       {
74752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74753       };
74754     } catch (...) {
74755       {
74756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74757       };
74758     }
74759   }
74760
74761   jresult = result;
74762   return jresult;
74763 }
74764
74765
74766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74767   unsigned int jresult ;
74768   Dali::Toolkit::ControlOrientation::Type arg1 ;
74769   bool result;
74770
74771   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74772   {
74773     try {
74774       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74775     } catch (std::out_of_range& e) {
74776       {
74777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74778       };
74779     } catch (std::exception& e) {
74780       {
74781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74782       };
74783     } catch (Dali::DaliException e) {
74784       {
74785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74786       };
74787     } catch (...) {
74788       {
74789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74790       };
74791     }
74792   }
74793
74794   jresult = result;
74795   return jresult;
74796 }
74797
74798
74799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74800   void * jresult ;
74801   unsigned int arg1 ;
74802   unsigned int arg2 ;
74803   Dali::Toolkit::ItemRange *result = 0 ;
74804
74805   arg1 = (unsigned int)jarg1;
74806   arg2 = (unsigned int)jarg2;
74807   {
74808     try {
74809       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74810     } catch (std::out_of_range& e) {
74811       {
74812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74813       };
74814     } catch (std::exception& e) {
74815       {
74816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74817       };
74818     } catch (Dali::DaliException e) {
74819       {
74820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74821       };
74822     } catch (...) {
74823       {
74824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74825       };
74826     }
74827   }
74828
74829   jresult = (void *)result;
74830   return jresult;
74831 }
74832
74833
74834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74835   void * jresult ;
74836   Dali::Toolkit::ItemRange *arg1 = 0 ;
74837   Dali::Toolkit::ItemRange *result = 0 ;
74838
74839   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74840   if (!arg1) {
74841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74842     return 0;
74843   }
74844   {
74845     try {
74846       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74847     } catch (std::out_of_range& e) {
74848       {
74849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74850       };
74851     } catch (std::exception& e) {
74852       {
74853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74854       };
74855     } catch (Dali::DaliException e) {
74856       {
74857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74858       };
74859     } catch (...) {
74860       {
74861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74862       };
74863     }
74864   }
74865
74866   jresult = (void *)result;
74867   return jresult;
74868 }
74869
74870
74871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74872   void * jresult ;
74873   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74874   Dali::Toolkit::ItemRange *arg2 = 0 ;
74875   Dali::Toolkit::ItemRange *result = 0 ;
74876
74877   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74878   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74879   if (!arg2) {
74880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74881     return 0;
74882   }
74883   {
74884     try {
74885       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74886     } catch (std::out_of_range& e) {
74887       {
74888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74889       };
74890     } catch (std::exception& e) {
74891       {
74892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74893       };
74894     } catch (Dali::DaliException e) {
74895       {
74896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74897       };
74898     } catch (...) {
74899       {
74900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74901       };
74902     }
74903   }
74904
74905   jresult = (void *)result;
74906   return jresult;
74907 }
74908
74909
74910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74911   unsigned int jresult ;
74912   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74913   unsigned int arg2 ;
74914   bool result;
74915
74916   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74917   arg2 = (unsigned int)jarg2;
74918   {
74919     try {
74920       result = (bool)(arg1)->Within(arg2);
74921     } catch (std::out_of_range& e) {
74922       {
74923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74924       };
74925     } catch (std::exception& e) {
74926       {
74927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74928       };
74929     } catch (Dali::DaliException e) {
74930       {
74931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74932       };
74933     } catch (...) {
74934       {
74935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74936       };
74937     }
74938   }
74939
74940   jresult = result;
74941   return jresult;
74942 }
74943
74944
74945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74946   void * jresult ;
74947   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74948   Dali::Toolkit::ItemRange *arg2 = 0 ;
74949   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74950
74951   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74952   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74953   if (!arg2) {
74954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74955     return 0;
74956   }
74957   {
74958     try {
74959       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74960     } catch (std::out_of_range& e) {
74961       {
74962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74963       };
74964     } catch (std::exception& e) {
74965       {
74966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74967       };
74968     } catch (Dali::DaliException e) {
74969       {
74970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74971       };
74972     } catch (...) {
74973       {
74974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74975       };
74976     }
74977   }
74978
74979   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74980   return jresult;
74981 }
74982
74983
74984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74985   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74986   unsigned int arg2 ;
74987
74988   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74989   arg2 = (unsigned int)jarg2;
74990   if (arg1) (arg1)->begin = arg2;
74991 }
74992
74993
74994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74995   unsigned int jresult ;
74996   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74997   unsigned int result;
74998
74999   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75000   result = (unsigned int) ((arg1)->begin);
75001   jresult = result;
75002   return jresult;
75003 }
75004
75005
75006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
75007   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75008   unsigned int arg2 ;
75009
75010   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75011   arg2 = (unsigned int)jarg2;
75012   if (arg1) (arg1)->end = arg2;
75013 }
75014
75015
75016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
75017   unsigned int jresult ;
75018   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75019   unsigned int result;
75020
75021   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75022   result = (unsigned int) ((arg1)->end);
75023   jresult = result;
75024   return jresult;
75025 }
75026
75027
75028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
75029   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75030
75031   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75032   {
75033     try {
75034       delete arg1;
75035     } catch (std::out_of_range& e) {
75036       {
75037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75038       };
75039     } catch (std::exception& e) {
75040       {
75041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75042       };
75043     } catch (Dali::DaliException e) {
75044       {
75045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75046       };
75047     } catch (...) {
75048       {
75049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75050       };
75051     }
75052   }
75053
75054 }
75055
75056
75057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
75058   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75059
75060   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75061   {
75062     try {
75063       delete arg1;
75064     } catch (std::out_of_range& e) {
75065       {
75066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75067       };
75068     } catch (std::exception& e) {
75069       {
75070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75071       };
75072     } catch (Dali::DaliException e) {
75073       {
75074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75075       };
75076     } catch (...) {
75077       {
75078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75079       };
75080     }
75081   }
75082
75083 }
75084
75085
75086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75087   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75088   Dali::Toolkit::ControlOrientation::Type arg2 ;
75089
75090   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75091   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75092   {
75093     try {
75094       (arg1)->SetOrientation(arg2);
75095     } catch (std::out_of_range& e) {
75096       {
75097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75098       };
75099     } catch (std::exception& e) {
75100       {
75101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75102       };
75103     } catch (Dali::DaliException e) {
75104       {
75105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75106       };
75107     } catch (...) {
75108       {
75109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75110       };
75111     }
75112   }
75113
75114 }
75115
75116
75117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75118   int jresult ;
75119   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75120   Dali::Toolkit::ControlOrientation::Type result;
75121
75122   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75123   {
75124     try {
75125       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75126     } catch (std::out_of_range& e) {
75127       {
75128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75129       };
75130     } catch (std::exception& e) {
75131       {
75132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75133       };
75134     } catch (Dali::DaliException e) {
75135       {
75136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75137       };
75138     } catch (...) {
75139       {
75140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75141       };
75142     }
75143   }
75144
75145   jresult = (int)result;
75146   return jresult;
75147 }
75148
75149
75150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75151   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75152   Dali::Property::Map *arg2 = 0 ;
75153
75154   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75155   arg2 = (Dali::Property::Map *)jarg2;
75156   if (!arg2) {
75157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75158     return ;
75159   }
75160   {
75161     try {
75162       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75163     } catch (std::out_of_range& e) {
75164       {
75165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75166       };
75167     } catch (std::exception& e) {
75168       {
75169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75170       };
75171     } catch (Dali::DaliException e) {
75172       {
75173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75174       };
75175     } catch (...) {
75176       {
75177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75178       };
75179     }
75180   }
75181
75182 }
75183
75184
75185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75186   void * jresult ;
75187   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75188   Dali::Property::Map result;
75189
75190   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75191   {
75192     try {
75193       result = (arg1)->GetLayoutProperties();
75194     } catch (std::out_of_range& e) {
75195       {
75196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75197       };
75198     } catch (std::exception& e) {
75199       {
75200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75201       };
75202     } catch (Dali::DaliException e) {
75203       {
75204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75205       };
75206     } catch (...) {
75207       {
75208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75209       };
75210     }
75211   }
75212
75213   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75214   return jresult;
75215 }
75216
75217
75218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75219   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75220   unsigned int arg2 ;
75221   Dali::Vector3 *arg3 = 0 ;
75222   Dali::Vector3 *arg4 = 0 ;
75223
75224   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75225   arg2 = (unsigned int)jarg2;
75226   arg3 = (Dali::Vector3 *)jarg3;
75227   if (!arg3) {
75228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75229     return ;
75230   }
75231   arg4 = (Dali::Vector3 *)jarg4;
75232   if (!arg4) {
75233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75234     return ;
75235   }
75236   {
75237     try {
75238       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75239     } catch (std::out_of_range& e) {
75240       {
75241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75242       };
75243     } catch (std::exception& e) {
75244       {
75245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75246       };
75247     } catch (Dali::DaliException e) {
75248       {
75249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75250       };
75251     } catch (...) {
75252       {
75253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75254       };
75255     }
75256   }
75257
75258 }
75259
75260
75261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75262   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75263   Dali::Vector3 *arg2 = 0 ;
75264
75265   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75266   arg2 = (Dali::Vector3 *)jarg2;
75267   if (!arg2) {
75268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75269     return ;
75270   }
75271   {
75272     try {
75273       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75274     } catch (std::out_of_range& e) {
75275       {
75276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75277       };
75278     } catch (std::exception& e) {
75279       {
75280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75281       };
75282     } catch (Dali::DaliException e) {
75283       {
75284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75285       };
75286     } catch (...) {
75287       {
75288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75289       };
75290     }
75291   }
75292
75293 }
75294
75295
75296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75297   float jresult ;
75298   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75299   unsigned int arg2 ;
75300   Dali::Vector3 arg3 ;
75301   Dali::Vector3 *argp3 ;
75302   float result;
75303
75304   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75305   arg2 = (unsigned int)jarg2;
75306   argp3 = (Dali::Vector3 *)jarg3;
75307   if (!argp3) {
75308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75309     return 0;
75310   }
75311   arg3 = *argp3;
75312   {
75313     try {
75314       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75315     } catch (std::out_of_range& e) {
75316       {
75317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75318       };
75319     } catch (std::exception& e) {
75320       {
75321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75322       };
75323     } catch (Dali::DaliException e) {
75324       {
75325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75326       };
75327     } catch (...) {
75328       {
75329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75330       };
75331     }
75332   }
75333
75334   jresult = result;
75335   return jresult;
75336 }
75337
75338
75339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75340   float jresult ;
75341   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75342   float arg2 ;
75343   float result;
75344
75345   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75346   arg2 = (float)jarg2;
75347   {
75348     try {
75349       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75350     } catch (std::out_of_range& e) {
75351       {
75352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75353       };
75354     } catch (std::exception& e) {
75355       {
75356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75357       };
75358     } catch (Dali::DaliException e) {
75359       {
75360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75361       };
75362     } catch (...) {
75363       {
75364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75365       };
75366     }
75367   }
75368
75369   jresult = result;
75370   return jresult;
75371 }
75372
75373
75374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75375   float jresult ;
75376   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75377   unsigned int arg2 ;
75378   float result;
75379
75380   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75381   arg2 = (unsigned int)jarg2;
75382   {
75383     try {
75384       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75385     } catch (std::out_of_range& e) {
75386       {
75387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75388       };
75389     } catch (std::exception& e) {
75390       {
75391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75392       };
75393     } catch (Dali::DaliException e) {
75394       {
75395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75396       };
75397     } catch (...) {
75398       {
75399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75400       };
75401     }
75402   }
75403
75404   jresult = result;
75405   return jresult;
75406 }
75407
75408
75409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75410   void * jresult ;
75411   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75412   float arg2 ;
75413   Dali::Vector3 arg3 ;
75414   Dali::Vector3 *argp3 ;
75415   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75416
75417   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75418   arg2 = (float)jarg2;
75419   argp3 = (Dali::Vector3 *)jarg3;
75420   if (!argp3) {
75421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75422     return 0;
75423   }
75424   arg3 = *argp3;
75425   {
75426     try {
75427       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75428     } catch (std::out_of_range& e) {
75429       {
75430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75431       };
75432     } catch (std::exception& e) {
75433       {
75434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75435       };
75436     } catch (Dali::DaliException e) {
75437       {
75438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75439       };
75440     } catch (...) {
75441       {
75442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75443       };
75444     }
75445   }
75446
75447   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75448   return jresult;
75449 }
75450
75451
75452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75453   float jresult ;
75454   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75455   int arg2 ;
75456   float arg3 ;
75457   Dali::Vector3 *arg4 = 0 ;
75458   float result;
75459
75460   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75461   arg2 = (int)jarg2;
75462   arg3 = (float)jarg3;
75463   arg4 = (Dali::Vector3 *)jarg4;
75464   if (!arg4) {
75465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75466     return 0;
75467   }
75468   {
75469     try {
75470       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75471     } catch (std::out_of_range& e) {
75472       {
75473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75474       };
75475     } catch (std::exception& e) {
75476       {
75477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75478       };
75479     } catch (Dali::DaliException e) {
75480       {
75481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75482       };
75483     } catch (...) {
75484       {
75485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75486       };
75487     }
75488   }
75489
75490   jresult = result;
75491   return jresult;
75492 }
75493
75494
75495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75496   unsigned int jresult ;
75497   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75498   Dali::Vector3 arg2 ;
75499   Dali::Vector3 *argp2 ;
75500   unsigned int result;
75501
75502   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75503   argp2 = (Dali::Vector3 *)jarg2;
75504   if (!argp2) {
75505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75506     return 0;
75507   }
75508   arg2 = *argp2;
75509   {
75510     try {
75511       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75512     } catch (std::out_of_range& e) {
75513       {
75514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75515       };
75516     } catch (std::exception& e) {
75517       {
75518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75519       };
75520     } catch (Dali::DaliException e) {
75521       {
75522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75523       };
75524     } catch (...) {
75525       {
75526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75527       };
75528     }
75529   }
75530
75531   jresult = result;
75532   return jresult;
75533 }
75534
75535
75536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75537   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75538   unsigned int arg2 ;
75539   Dali::Vector3 *arg3 = 0 ;
75540   Dali::Vector3 *arg4 = 0 ;
75541
75542   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75543   arg2 = (unsigned int)jarg2;
75544   arg3 = (Dali::Vector3 *)jarg3;
75545   if (!arg3) {
75546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75547     return ;
75548   }
75549   arg4 = (Dali::Vector3 *)jarg4;
75550   if (!arg4) {
75551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75552     return ;
75553   }
75554   {
75555     try {
75556       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75557     } catch (std::out_of_range& e) {
75558       {
75559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75560       };
75561     } catch (std::exception& e) {
75562       {
75563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75564       };
75565     } catch (Dali::DaliException e) {
75566       {
75567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75568       };
75569     } catch (...) {
75570       {
75571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75572       };
75573     }
75574   }
75575
75576 }
75577
75578
75579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75580   void * jresult ;
75581   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75582   Dali::Degree result;
75583
75584   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75585   {
75586     try {
75587       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75588     } catch (std::out_of_range& e) {
75589       {
75590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75591       };
75592     } catch (std::exception& e) {
75593       {
75594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75595       };
75596     } catch (Dali::DaliException e) {
75597       {
75598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75599       };
75600     } catch (...) {
75601       {
75602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75603       };
75604     }
75605   }
75606
75607   jresult = new Dali::Degree((const Dali::Degree &)result);
75608   return jresult;
75609 }
75610
75611
75612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75613   float jresult ;
75614   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75615   float result;
75616
75617   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75618   {
75619     try {
75620       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75621     } catch (std::out_of_range& e) {
75622       {
75623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75624       };
75625     } catch (std::exception& e) {
75626       {
75627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75628       };
75629     } catch (Dali::DaliException e) {
75630       {
75631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75632       };
75633     } catch (...) {
75634       {
75635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75636       };
75637     }
75638   }
75639
75640   jresult = result;
75641   return jresult;
75642 }
75643
75644
75645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75646   float jresult ;
75647   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75648   float result;
75649
75650   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75651   {
75652     try {
75653       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75654     } catch (std::out_of_range& e) {
75655       {
75656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75657       };
75658     } catch (std::exception& e) {
75659       {
75660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75661       };
75662     } catch (Dali::DaliException e) {
75663       {
75664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75665       };
75666     } catch (...) {
75667       {
75668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75669       };
75670     }
75671   }
75672
75673   jresult = result;
75674   return jresult;
75675 }
75676
75677
75678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75679   float jresult ;
75680   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75681   float result;
75682
75683   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75684   {
75685     try {
75686       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75687     } catch (std::out_of_range& e) {
75688       {
75689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75690       };
75691     } catch (std::exception& e) {
75692       {
75693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75694       };
75695     } catch (Dali::DaliException e) {
75696       {
75697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75698       };
75699     } catch (...) {
75700       {
75701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75702       };
75703     }
75704   }
75705
75706   jresult = result;
75707   return jresult;
75708 }
75709
75710
75711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75712   int jresult ;
75713   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75714   int arg2 ;
75715   int arg3 ;
75716   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75717   bool arg5 ;
75718   int result;
75719
75720   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75721   arg2 = (int)jarg2;
75722   arg3 = (int)jarg3;
75723   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75724   arg5 = jarg5 ? true : false;
75725   {
75726     try {
75727       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75728     } catch (std::out_of_range& e) {
75729       {
75730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75731       };
75732     } catch (std::exception& e) {
75733       {
75734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75735       };
75736     } catch (Dali::DaliException e) {
75737       {
75738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75739       };
75740     } catch (...) {
75741       {
75742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75743       };
75744     }
75745   }
75746
75747   jresult = result;
75748   return jresult;
75749 }
75750
75751
75752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75753   float jresult ;
75754   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75755   float result;
75756
75757   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75758   {
75759     try {
75760       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75761     } catch (std::out_of_range& e) {
75762       {
75763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75764       };
75765     } catch (std::exception& e) {
75766       {
75767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75768       };
75769     } catch (Dali::DaliException e) {
75770       {
75771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75772       };
75773     } catch (...) {
75774       {
75775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75776       };
75777     }
75778   }
75779
75780   jresult = result;
75781   return jresult;
75782 }
75783
75784
75785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75786   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75787   Dali::Actor *arg2 = 0 ;
75788   int arg3 ;
75789   Dali::Vector3 *arg4 = 0 ;
75790   Dali::Actor *arg5 = 0 ;
75791
75792   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75793   arg2 = (Dali::Actor *)jarg2;
75794   if (!arg2) {
75795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75796     return ;
75797   }
75798   arg3 = (int)jarg3;
75799   arg4 = (Dali::Vector3 *)jarg4;
75800   if (!arg4) {
75801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75802     return ;
75803   }
75804   arg5 = (Dali::Actor *)jarg5;
75805   if (!arg5) {
75806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75807     return ;
75808   }
75809   {
75810     try {
75811       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75812     } catch (std::out_of_range& e) {
75813       {
75814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75815       };
75816     } catch (std::exception& e) {
75817       {
75818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75819       };
75820     } catch (Dali::DaliException e) {
75821       {
75822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75823       };
75824     } catch (...) {
75825       {
75826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75827       };
75828     }
75829   }
75830
75831 }
75832
75833
75834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75835   void * jresult ;
75836   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75837   int arg2 ;
75838   float arg3 ;
75839   Dali::Vector3 *arg4 = 0 ;
75840   Dali::Vector3 result;
75841
75842   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75843   arg2 = (int)jarg2;
75844   arg3 = (float)jarg3;
75845   arg4 = (Dali::Vector3 *)jarg4;
75846   if (!arg4) {
75847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75848     return 0;
75849   }
75850   {
75851     try {
75852       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75853     } catch (std::out_of_range& e) {
75854       {
75855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75856       };
75857     } catch (std::exception& e) {
75858       {
75859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75860       };
75861     } catch (Dali::DaliException e) {
75862       {
75863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75864       };
75865     } catch (...) {
75866       {
75867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75868       };
75869     }
75870   }
75871
75872   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75873   return jresult;
75874 }
75875
75876
75877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75878   void * jresult ;
75879   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75880   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75881
75882   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75883   {
75884     try {
75885       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75886     } catch (std::out_of_range& e) {
75887       {
75888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75889       };
75890     } catch (std::exception& e) {
75891       {
75892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75893       };
75894     } catch (Dali::DaliException e) {
75895       {
75896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75897       };
75898     } catch (...) {
75899       {
75900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75901       };
75902     }
75903   }
75904
75905   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75906   return jresult;
75907 }
75908
75909
75910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75911   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75912
75913   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75914   {
75915     try {
75916       delete arg1;
75917     } catch (std::out_of_range& e) {
75918       {
75919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75920       };
75921     } catch (std::exception& e) {
75922       {
75923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75924       };
75925     } catch (Dali::DaliException e) {
75926       {
75927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75928       };
75929     } catch (...) {
75930       {
75931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75932       };
75933     }
75934   }
75935
75936 }
75937
75938
75939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75940   unsigned int jresult ;
75941   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75942   unsigned int result;
75943
75944   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75945   {
75946     try {
75947       result = (unsigned int)(arg1)->GetNumberOfItems();
75948     } catch (std::out_of_range& e) {
75949       {
75950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75951       };
75952     } catch (std::exception& e) {
75953       {
75954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75955       };
75956     } catch (Dali::DaliException e) {
75957       {
75958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75959       };
75960     } catch (...) {
75961       {
75962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75963       };
75964     }
75965   }
75966
75967   jresult = result;
75968   return jresult;
75969 }
75970
75971
75972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75973   void * jresult ;
75974   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75975   unsigned int arg2 ;
75976   Dali::Actor result;
75977
75978   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75979   arg2 = (unsigned int)jarg2;
75980   {
75981     try {
75982       result = (arg1)->NewItem(arg2);
75983     } catch (std::out_of_range& e) {
75984       {
75985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75986       };
75987     } catch (std::exception& e) {
75988       {
75989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75990       };
75991     } catch (Dali::DaliException e) {
75992       {
75993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75994       };
75995     } catch (...) {
75996       {
75997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75998       };
75999     }
76000   }
76001
76002   jresult = new Dali::Actor((const Dali::Actor &)result);
76003   return jresult;
76004 }
76005
76006
76007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
76008   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76009   unsigned int arg2 ;
76010   Dali::Actor arg3 ;
76011   Dali::Actor *argp3 ;
76012
76013   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76014   arg2 = (unsigned int)jarg2;
76015   argp3 = (Dali::Actor *)jarg3;
76016   if (!argp3) {
76017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76018     return ;
76019   }
76020   arg3 = *argp3;
76021   {
76022     try {
76023       (arg1)->ItemReleased(arg2,arg3);
76024     } catch (std::out_of_range& e) {
76025       {
76026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76027       };
76028     } catch (std::exception& e) {
76029       {
76030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76031       };
76032     } catch (Dali::DaliException e) {
76033       {
76034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76035       };
76036     } catch (...) {
76037       {
76038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76039       };
76040     }
76041   }
76042
76043 }
76044
76045
76046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
76047   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76048   unsigned int arg2 ;
76049   Dali::Actor arg3 ;
76050   Dali::Actor *argp3 ;
76051
76052   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76053   arg2 = (unsigned int)jarg2;
76054   argp3 = (Dali::Actor *)jarg3;
76055   if (!argp3) {
76056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76057     return ;
76058   }
76059   arg3 = *argp3;
76060   {
76061     try {
76062       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
76063     } catch (std::out_of_range& e) {
76064       {
76065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76066       };
76067     } catch (std::exception& e) {
76068       {
76069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76070       };
76071     } catch (Dali::DaliException e) {
76072       {
76073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76074       };
76075     } catch (...) {
76076       {
76077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76078       };
76079     }
76080   }
76081
76082 }
76083
76084
76085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76086   void * jresult ;
76087   Dali::Toolkit::ItemFactory *result = 0 ;
76088
76089   {
76090     try {
76091       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76092     } catch (std::out_of_range& e) {
76093       {
76094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76095       };
76096     } catch (std::exception& e) {
76097       {
76098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76099       };
76100     } catch (Dali::DaliException e) {
76101       {
76102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76103       };
76104     } catch (...) {
76105       {
76106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76107       };
76108     }
76109   }
76110
76111   jresult = (void *)result;
76112   return jresult;
76113 }
76114
76115
76116 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) {
76117   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76118   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76119   if (director) {
76120     director->swig_connect_director(callback0, callback1, callback2);
76121   }
76122 }
76123
76124
76125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76126   int jresult ;
76127   int result;
76128
76129   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76130   jresult = (int)result;
76131   return jresult;
76132 }
76133
76134
76135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76136   int jresult ;
76137   int result;
76138
76139   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76140   jresult = (int)result;
76141   return jresult;
76142 }
76143
76144
76145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76146   int jresult ;
76147   int result;
76148
76149   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76150   jresult = (int)result;
76151   return jresult;
76152 }
76153
76154
76155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76156   int jresult ;
76157   int result;
76158
76159   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76160   jresult = (int)result;
76161   return jresult;
76162 }
76163
76164
76165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76166   int jresult ;
76167   int result;
76168
76169   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76170   jresult = (int)result;
76171   return jresult;
76172 }
76173
76174
76175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76176   int jresult ;
76177   int result;
76178
76179   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76180   jresult = (int)result;
76181   return jresult;
76182 }
76183
76184
76185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76186   int jresult ;
76187   int result;
76188
76189   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76190   jresult = (int)result;
76191   return jresult;
76192 }
76193
76194
76195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76196   int jresult ;
76197   int result;
76198
76199   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76200   jresult = (int)result;
76201   return jresult;
76202 }
76203
76204
76205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76206   int jresult ;
76207   int result;
76208
76209   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76210   jresult = (int)result;
76211   return jresult;
76212 }
76213
76214
76215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76216   int jresult ;
76217   int result;
76218
76219   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76220   jresult = (int)result;
76221   return jresult;
76222 }
76223
76224
76225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76226   int jresult ;
76227   int result;
76228
76229   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76230   jresult = (int)result;
76231   return jresult;
76232 }
76233
76234
76235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76236   void * jresult ;
76237   Dali::Toolkit::ItemView::Property *result = 0 ;
76238
76239   {
76240     try {
76241       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76242     } catch (std::out_of_range& e) {
76243       {
76244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76245       };
76246     } catch (std::exception& e) {
76247       {
76248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76249       };
76250     } catch (Dali::DaliException e) {
76251       {
76252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76253       };
76254     } catch (...) {
76255       {
76256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76257       };
76258     }
76259   }
76260
76261   jresult = (void *)result;
76262   return jresult;
76263 }
76264
76265
76266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76267   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76268
76269   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76270   {
76271     try {
76272       delete arg1;
76273     } catch (std::out_of_range& e) {
76274       {
76275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76276       };
76277     } catch (std::exception& e) {
76278       {
76279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76280       };
76281     } catch (Dali::DaliException e) {
76282       {
76283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76284       };
76285     } catch (...) {
76286       {
76287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76288       };
76289     }
76290   }
76291
76292 }
76293
76294
76295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76296   void * jresult ;
76297   Dali::Toolkit::ItemView *result = 0 ;
76298
76299   {
76300     try {
76301       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76302     } catch (std::out_of_range& e) {
76303       {
76304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76305       };
76306     } catch (std::exception& e) {
76307       {
76308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76309       };
76310     } catch (Dali::DaliException e) {
76311       {
76312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76313       };
76314     } catch (...) {
76315       {
76316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76317       };
76318     }
76319   }
76320
76321   jresult = (void *)result;
76322   return jresult;
76323 }
76324
76325
76326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76327   void * jresult ;
76328   Dali::Toolkit::ItemView *arg1 = 0 ;
76329   Dali::Toolkit::ItemView *result = 0 ;
76330
76331   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76332   if (!arg1) {
76333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76334     return 0;
76335   }
76336   {
76337     try {
76338       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76339     } catch (std::out_of_range& e) {
76340       {
76341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76342       };
76343     } catch (std::exception& e) {
76344       {
76345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76346       };
76347     } catch (Dali::DaliException e) {
76348       {
76349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76350       };
76351     } catch (...) {
76352       {
76353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76354       };
76355     }
76356   }
76357
76358   jresult = (void *)result;
76359   return jresult;
76360 }
76361
76362
76363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76364   void * jresult ;
76365   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76366   Dali::Toolkit::ItemView *arg2 = 0 ;
76367   Dali::Toolkit::ItemView *result = 0 ;
76368
76369   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76370   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76371   if (!arg2) {
76372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76373     return 0;
76374   }
76375   {
76376     try {
76377       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76378     } catch (std::out_of_range& e) {
76379       {
76380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76381       };
76382     } catch (std::exception& e) {
76383       {
76384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76385       };
76386     } catch (Dali::DaliException e) {
76387       {
76388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76389       };
76390     } catch (...) {
76391       {
76392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76393       };
76394     }
76395   }
76396
76397   jresult = (void *)result;
76398   return jresult;
76399 }
76400
76401
76402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76403   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76404
76405   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76406   {
76407     try {
76408       delete arg1;
76409     } catch (std::out_of_range& e) {
76410       {
76411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76412       };
76413     } catch (std::exception& e) {
76414       {
76415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76416       };
76417     } catch (Dali::DaliException e) {
76418       {
76419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76420       };
76421     } catch (...) {
76422       {
76423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76424       };
76425     }
76426   }
76427
76428 }
76429
76430
76431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76432   void * jresult ;
76433   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76434   Dali::Toolkit::ItemView result;
76435
76436   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76437   if (!arg1) {
76438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76439     return 0;
76440   }
76441   {
76442     try {
76443       result = Dali::Toolkit::ItemView::New(*arg1);
76444     } catch (std::out_of_range& e) {
76445       {
76446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76447       };
76448     } catch (std::exception& e) {
76449       {
76450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76451       };
76452     } catch (Dali::DaliException e) {
76453       {
76454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76455       };
76456     } catch (...) {
76457       {
76458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76459       };
76460     }
76461   }
76462
76463   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76464   return jresult;
76465 }
76466
76467
76468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76469   void * jresult ;
76470   Dali::BaseHandle arg1 ;
76471   Dali::BaseHandle *argp1 ;
76472   Dali::Toolkit::ItemView result;
76473
76474   argp1 = (Dali::BaseHandle *)jarg1;
76475   if (!argp1) {
76476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76477     return 0;
76478   }
76479   arg1 = *argp1;
76480   {
76481     try {
76482       result = Dali::Toolkit::ItemView::DownCast(arg1);
76483     } catch (std::out_of_range& e) {
76484       {
76485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76486       };
76487     } catch (std::exception& e) {
76488       {
76489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76490       };
76491     } catch (Dali::DaliException e) {
76492       {
76493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76494       };
76495     } catch (...) {
76496       {
76497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76498       };
76499     }
76500   }
76501
76502   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76503   return jresult;
76504 }
76505
76506
76507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76508   unsigned int jresult ;
76509   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76510   unsigned int result;
76511
76512   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76513   {
76514     try {
76515       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76516     } catch (std::out_of_range& e) {
76517       {
76518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76519       };
76520     } catch (std::exception& e) {
76521       {
76522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76523       };
76524     } catch (Dali::DaliException e) {
76525       {
76526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76527       };
76528     } catch (...) {
76529       {
76530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76531       };
76532     }
76533   }
76534
76535   jresult = result;
76536   return jresult;
76537 }
76538
76539
76540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76541   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76542   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76543
76544   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76545   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76546   if (!arg2) {
76547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76548     return ;
76549   }
76550   {
76551     try {
76552       (arg1)->AddLayout(*arg2);
76553     } catch (std::out_of_range& e) {
76554       {
76555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76556       };
76557     } catch (std::exception& e) {
76558       {
76559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76560       };
76561     } catch (Dali::DaliException e) {
76562       {
76563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76564       };
76565     } catch (...) {
76566       {
76567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76568       };
76569     }
76570   }
76571
76572 }
76573
76574
76575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76576   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76577   unsigned int arg2 ;
76578
76579   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76580   arg2 = (unsigned int)jarg2;
76581   {
76582     try {
76583       (arg1)->RemoveLayout(arg2);
76584     } catch (std::out_of_range& e) {
76585       {
76586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76587       };
76588     } catch (std::exception& e) {
76589       {
76590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76591       };
76592     } catch (Dali::DaliException e) {
76593       {
76594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76595       };
76596     } catch (...) {
76597       {
76598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76599       };
76600     }
76601   }
76602
76603 }
76604
76605
76606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76607   void * jresult ;
76608   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76609   unsigned int arg2 ;
76610   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76611
76612   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76613   arg2 = (unsigned int)jarg2;
76614   {
76615     try {
76616       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76617     } catch (std::out_of_range& e) {
76618       {
76619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76620       };
76621     } catch (std::exception& e) {
76622       {
76623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76624       };
76625     } catch (Dali::DaliException e) {
76626       {
76627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76628       };
76629     } catch (...) {
76630       {
76631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76632       };
76633     }
76634   }
76635
76636   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76637   return jresult;
76638 }
76639
76640
76641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76642   void * jresult ;
76643   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76644   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76645
76646   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76647   {
76648     try {
76649       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76650     } catch (std::out_of_range& e) {
76651       {
76652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76653       };
76654     } catch (std::exception& e) {
76655       {
76656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76657       };
76658     } catch (Dali::DaliException e) {
76659       {
76660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76661       };
76662     } catch (...) {
76663       {
76664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76665       };
76666     }
76667   }
76668
76669   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76670   return jresult;
76671 }
76672
76673
76674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76675   float jresult ;
76676   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76677   Dali::Toolkit::ItemId arg2 ;
76678   float result;
76679
76680   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76681   arg2 = (Dali::Toolkit::ItemId)jarg2;
76682   {
76683     try {
76684       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76685     } catch (std::out_of_range& e) {
76686       {
76687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76688       };
76689     } catch (std::exception& e) {
76690       {
76691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76692       };
76693     } catch (Dali::DaliException e) {
76694       {
76695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76696       };
76697     } catch (...) {
76698       {
76699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76700       };
76701     }
76702   }
76703
76704   jresult = result;
76705   return jresult;
76706 }
76707
76708
76709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76710   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76711   unsigned int arg2 ;
76712   Dali::Vector3 arg3 ;
76713   float arg4 ;
76714   Dali::Vector3 *argp3 ;
76715
76716   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76717   arg2 = (unsigned int)jarg2;
76718   argp3 = (Dali::Vector3 *)jarg3;
76719   if (!argp3) {
76720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76721     return ;
76722   }
76723   arg3 = *argp3;
76724   arg4 = (float)jarg4;
76725   {
76726     try {
76727       (arg1)->ActivateLayout(arg2,arg3,arg4);
76728     } catch (std::out_of_range& e) {
76729       {
76730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76731       };
76732     } catch (std::exception& e) {
76733       {
76734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76735       };
76736     } catch (Dali::DaliException e) {
76737       {
76738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76739       };
76740     } catch (...) {
76741       {
76742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76743       };
76744     }
76745   }
76746
76747 }
76748
76749
76750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76751   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76752
76753   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76754   {
76755     try {
76756       (arg1)->DeactivateCurrentLayout();
76757     } catch (std::out_of_range& e) {
76758       {
76759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76760       };
76761     } catch (std::exception& e) {
76762       {
76763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76764       };
76765     } catch (Dali::DaliException e) {
76766       {
76767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76768       };
76769     } catch (...) {
76770       {
76771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76772       };
76773     }
76774   }
76775
76776 }
76777
76778
76779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76780   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76781   float arg2 ;
76782
76783   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76784   arg2 = (float)jarg2;
76785   {
76786     try {
76787       (arg1)->SetMinimumSwipeSpeed(arg2);
76788     } catch (std::out_of_range& e) {
76789       {
76790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76791       };
76792     } catch (std::exception& e) {
76793       {
76794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76795       };
76796     } catch (Dali::DaliException e) {
76797       {
76798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76799       };
76800     } catch (...) {
76801       {
76802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76803       };
76804     }
76805   }
76806
76807 }
76808
76809
76810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76811   float jresult ;
76812   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76813   float result;
76814
76815   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76816   {
76817     try {
76818       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76819     } catch (std::out_of_range& e) {
76820       {
76821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76822       };
76823     } catch (std::exception& e) {
76824       {
76825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76826       };
76827     } catch (Dali::DaliException e) {
76828       {
76829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76830       };
76831     } catch (...) {
76832       {
76833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76834       };
76835     }
76836   }
76837
76838   jresult = result;
76839   return jresult;
76840 }
76841
76842
76843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76844   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76845   float arg2 ;
76846
76847   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76848   arg2 = (float)jarg2;
76849   {
76850     try {
76851       (arg1)->SetMinimumSwipeDistance(arg2);
76852     } catch (std::out_of_range& e) {
76853       {
76854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76855       };
76856     } catch (std::exception& e) {
76857       {
76858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76859       };
76860     } catch (Dali::DaliException e) {
76861       {
76862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76863       };
76864     } catch (...) {
76865       {
76866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76867       };
76868     }
76869   }
76870
76871 }
76872
76873
76874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76875   float jresult ;
76876   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76877   float result;
76878
76879   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76880   {
76881     try {
76882       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76883     } catch (std::out_of_range& e) {
76884       {
76885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76886       };
76887     } catch (std::exception& e) {
76888       {
76889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76890       };
76891     } catch (Dali::DaliException e) {
76892       {
76893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76894       };
76895     } catch (...) {
76896       {
76897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76898       };
76899     }
76900   }
76901
76902   jresult = result;
76903   return jresult;
76904 }
76905
76906
76907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76908   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76909   float arg2 ;
76910
76911   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76912   arg2 = (float)jarg2;
76913   {
76914     try {
76915       (arg1)->SetWheelScrollDistanceStep(arg2);
76916     } catch (std::out_of_range& e) {
76917       {
76918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76919       };
76920     } catch (std::exception& e) {
76921       {
76922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76923       };
76924     } catch (Dali::DaliException e) {
76925       {
76926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76927       };
76928     } catch (...) {
76929       {
76930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76931       };
76932     }
76933   }
76934
76935 }
76936
76937
76938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76939   float jresult ;
76940   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76941   float result;
76942
76943   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76944   {
76945     try {
76946       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76947     } catch (std::out_of_range& e) {
76948       {
76949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76950       };
76951     } catch (std::exception& e) {
76952       {
76953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76954       };
76955     } catch (Dali::DaliException e) {
76956       {
76957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76958       };
76959     } catch (...) {
76960       {
76961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76962       };
76963     }
76964   }
76965
76966   jresult = result;
76967   return jresult;
76968 }
76969
76970
76971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76972   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76973   bool arg2 ;
76974
76975   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76976   arg2 = jarg2 ? true : false;
76977   {
76978     try {
76979       (arg1)->SetAnchoring(arg2);
76980     } catch (std::out_of_range& e) {
76981       {
76982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76983       };
76984     } catch (std::exception& e) {
76985       {
76986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76987       };
76988     } catch (Dali::DaliException e) {
76989       {
76990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76991       };
76992     } catch (...) {
76993       {
76994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76995       };
76996     }
76997   }
76998
76999 }
77000
77001 //// ========================= end of part 3 =============================
77002
77003 //// ========================== start part 4 ===============================
77004
77005
77006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
77007   unsigned int jresult ;
77008   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77009   bool result;
77010
77011   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77012   {
77013     try {
77014       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
77015     } catch (std::out_of_range& e) {
77016       {
77017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77018       };
77019     } catch (std::exception& e) {
77020       {
77021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77022       };
77023     } catch (Dali::DaliException e) {
77024       {
77025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77026       };
77027     } catch (...) {
77028       {
77029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77030       };
77031     }
77032   }
77033
77034   jresult = result;
77035   return jresult;
77036 }
77037
77038
77039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
77040   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77041   float arg2 ;
77042
77043   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77044   arg2 = (float)jarg2;
77045   {
77046     try {
77047       (arg1)->SetAnchoringDuration(arg2);
77048     } catch (std::out_of_range& e) {
77049       {
77050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77051       };
77052     } catch (std::exception& e) {
77053       {
77054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77055       };
77056     } catch (Dali::DaliException e) {
77057       {
77058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77059       };
77060     } catch (...) {
77061       {
77062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77063       };
77064     }
77065   }
77066
77067 }
77068
77069
77070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77071   float jresult ;
77072   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77073   float result;
77074
77075   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77076   {
77077     try {
77078       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77079     } catch (std::out_of_range& e) {
77080       {
77081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77082       };
77083     } catch (std::exception& e) {
77084       {
77085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77086       };
77087     } catch (Dali::DaliException e) {
77088       {
77089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77090       };
77091     } catch (...) {
77092       {
77093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77094       };
77095     }
77096   }
77097
77098   jresult = result;
77099   return jresult;
77100 }
77101
77102
77103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77104   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77105   Dali::Toolkit::ItemId arg2 ;
77106   float arg3 ;
77107
77108   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77109   arg2 = (Dali::Toolkit::ItemId)jarg2;
77110   arg3 = (float)jarg3;
77111   {
77112     try {
77113       (arg1)->ScrollToItem(arg2,arg3);
77114     } catch (std::out_of_range& e) {
77115       {
77116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77117       };
77118     } catch (std::exception& e) {
77119       {
77120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77121       };
77122     } catch (Dali::DaliException e) {
77123       {
77124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77125       };
77126     } catch (...) {
77127       {
77128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77129       };
77130     }
77131   }
77132
77133 }
77134
77135
77136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77137   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77138   float arg2 ;
77139
77140   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77141   arg2 = (float)jarg2;
77142   {
77143     try {
77144       (arg1)->SetRefreshInterval(arg2);
77145     } catch (std::out_of_range& e) {
77146       {
77147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77148       };
77149     } catch (std::exception& e) {
77150       {
77151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77152       };
77153     } catch (Dali::DaliException e) {
77154       {
77155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77156       };
77157     } catch (...) {
77158       {
77159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77160       };
77161     }
77162   }
77163
77164 }
77165
77166
77167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77168   float jresult ;
77169   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77170   float result;
77171
77172   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77173   {
77174     try {
77175       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
77176     } catch (std::out_of_range& e) {
77177       {
77178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77179       };
77180     } catch (std::exception& e) {
77181       {
77182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77183       };
77184     } catch (Dali::DaliException e) {
77185       {
77186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77187       };
77188     } catch (...) {
77189       {
77190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77191       };
77192     }
77193   }
77194
77195   jresult = result;
77196   return jresult;
77197 }
77198
77199
77200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77201   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77202
77203   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77204   {
77205     try {
77206       (arg1)->Refresh();
77207     } catch (std::out_of_range& e) {
77208       {
77209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77210       };
77211     } catch (std::exception& e) {
77212       {
77213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77214       };
77215     } catch (Dali::DaliException e) {
77216       {
77217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77218       };
77219     } catch (...) {
77220       {
77221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77222       };
77223     }
77224   }
77225
77226 }
77227
77228
77229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77230   void * jresult ;
77231   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77232   Dali::Toolkit::ItemId arg2 ;
77233   Dali::Actor result;
77234
77235   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77236   arg2 = (Dali::Toolkit::ItemId)jarg2;
77237   {
77238     try {
77239       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77240     } catch (std::out_of_range& e) {
77241       {
77242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77243       };
77244     } catch (std::exception& e) {
77245       {
77246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77247       };
77248     } catch (Dali::DaliException e) {
77249       {
77250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77251       };
77252     } catch (...) {
77253       {
77254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77255       };
77256     }
77257   }
77258
77259   jresult = new Dali::Actor((const Dali::Actor &)result);
77260   return jresult;
77261 }
77262
77263
77264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77265   unsigned int jresult ;
77266   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77267   Dali::Actor arg2 ;
77268   Dali::Actor *argp2 ;
77269   Dali::Toolkit::ItemId result;
77270
77271   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77272   argp2 = (Dali::Actor *)jarg2;
77273   if (!argp2) {
77274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77275     return 0;
77276   }
77277   arg2 = *argp2;
77278   {
77279     try {
77280       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77281     } catch (std::out_of_range& e) {
77282       {
77283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77284       };
77285     } catch (std::exception& e) {
77286       {
77287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77288       };
77289     } catch (Dali::DaliException e) {
77290       {
77291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77292       };
77293     } catch (...) {
77294       {
77295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77296       };
77297     }
77298   }
77299
77300   jresult = result;
77301   return jresult;
77302 }
77303
77304
77305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77306   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77307   Dali::Toolkit::Item arg2 ;
77308   float arg3 ;
77309   Dali::Toolkit::Item *argp2 ;
77310
77311   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77312   argp2 = (Dali::Toolkit::Item *)jarg2;
77313   if (!argp2) {
77314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77315     return ;
77316   }
77317   arg2 = *argp2;
77318   arg3 = (float)jarg3;
77319   {
77320     try {
77321       (arg1)->InsertItem(arg2,arg3);
77322     } catch (std::out_of_range& e) {
77323       {
77324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77325       };
77326     } catch (std::exception& e) {
77327       {
77328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77329       };
77330     } catch (Dali::DaliException e) {
77331       {
77332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77333       };
77334     } catch (...) {
77335       {
77336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77337       };
77338     }
77339   }
77340
77341 }
77342
77343
77344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77345   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77346   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77347   float arg3 ;
77348
77349   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77350   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77351   if (!arg2) {
77352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77353     return ;
77354   }
77355   arg3 = (float)jarg3;
77356   {
77357     try {
77358       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77359     } catch (std::out_of_range& e) {
77360       {
77361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77362       };
77363     } catch (std::exception& e) {
77364       {
77365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77366       };
77367     } catch (Dali::DaliException e) {
77368       {
77369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77370       };
77371     } catch (...) {
77372       {
77373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77374       };
77375     }
77376   }
77377
77378 }
77379
77380
77381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77382   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77383   Dali::Toolkit::ItemId arg2 ;
77384   float arg3 ;
77385
77386   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77387   arg2 = (Dali::Toolkit::ItemId)jarg2;
77388   arg3 = (float)jarg3;
77389   {
77390     try {
77391       (arg1)->RemoveItem(arg2,arg3);
77392     } catch (std::out_of_range& e) {
77393       {
77394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77395       };
77396     } catch (std::exception& e) {
77397       {
77398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77399       };
77400     } catch (Dali::DaliException e) {
77401       {
77402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77403       };
77404     } catch (...) {
77405       {
77406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77407       };
77408     }
77409   }
77410
77411 }
77412
77413
77414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77415   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77416   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77417   float arg3 ;
77418
77419   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77420   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77421   if (!arg2) {
77422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77423     return ;
77424   }
77425   arg3 = (float)jarg3;
77426   {
77427     try {
77428       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77429     } catch (std::out_of_range& e) {
77430       {
77431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77432       };
77433     } catch (std::exception& e) {
77434       {
77435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77436       };
77437     } catch (Dali::DaliException e) {
77438       {
77439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77440       };
77441     } catch (...) {
77442       {
77443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77444       };
77445     }
77446   }
77447
77448 }
77449
77450
77451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77452   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77453   Dali::Toolkit::Item arg2 ;
77454   float arg3 ;
77455   Dali::Toolkit::Item *argp2 ;
77456
77457   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77458   argp2 = (Dali::Toolkit::Item *)jarg2;
77459   if (!argp2) {
77460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77461     return ;
77462   }
77463   arg2 = *argp2;
77464   arg3 = (float)jarg3;
77465   {
77466     try {
77467       (arg1)->ReplaceItem(arg2,arg3);
77468     } catch (std::out_of_range& e) {
77469       {
77470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77471       };
77472     } catch (std::exception& e) {
77473       {
77474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77475       };
77476     } catch (Dali::DaliException e) {
77477       {
77478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77479       };
77480     } catch (...) {
77481       {
77482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77483       };
77484     }
77485   }
77486
77487 }
77488
77489
77490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77491   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77492   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77493   float arg3 ;
77494
77495   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77496   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77497   if (!arg2) {
77498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77499     return ;
77500   }
77501   arg3 = (float)jarg3;
77502   {
77503     try {
77504       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77505     } catch (std::out_of_range& e) {
77506       {
77507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77508       };
77509     } catch (std::exception& e) {
77510       {
77511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77512       };
77513     } catch (Dali::DaliException e) {
77514       {
77515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77516       };
77517     } catch (...) {
77518       {
77519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77520       };
77521     }
77522   }
77523
77524 }
77525
77526
77527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77528   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77529   Dali::Vector3 *arg2 = 0 ;
77530
77531   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77532   arg2 = (Dali::Vector3 *)jarg2;
77533   if (!arg2) {
77534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77535     return ;
77536   }
77537   {
77538     try {
77539       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77540     } catch (std::out_of_range& e) {
77541       {
77542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77543       };
77544     } catch (std::exception& e) {
77545       {
77546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77547       };
77548     } catch (Dali::DaliException e) {
77549       {
77550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77551       };
77552     } catch (...) {
77553       {
77554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77555       };
77556     }
77557   }
77558
77559 }
77560
77561
77562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77563   void * jresult ;
77564   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77565   Dali::Vector3 result;
77566
77567   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77568   {
77569     try {
77570       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77571     } catch (std::out_of_range& e) {
77572       {
77573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77574       };
77575     } catch (std::exception& e) {
77576       {
77577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77578       };
77579     } catch (Dali::DaliException e) {
77580       {
77581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77582       };
77583     } catch (...) {
77584       {
77585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77586       };
77587     }
77588   }
77589
77590   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77591   return jresult;
77592 }
77593
77594
77595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77596   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77597   Dali::Vector3 *arg2 = 0 ;
77598
77599   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77600   arg2 = (Dali::Vector3 *)jarg2;
77601   if (!arg2) {
77602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77603     return ;
77604   }
77605   {
77606     try {
77607       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77608     } catch (std::out_of_range& e) {
77609       {
77610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77611       };
77612     } catch (std::exception& e) {
77613       {
77614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77615       };
77616     } catch (Dali::DaliException e) {
77617       {
77618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77619       };
77620     } catch (...) {
77621       {
77622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77623       };
77624     }
77625   }
77626
77627 }
77628
77629
77630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77631   void * jresult ;
77632   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77633   Dali::Vector3 result;
77634
77635   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77636   {
77637     try {
77638       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77639     } catch (std::out_of_range& e) {
77640       {
77641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77642       };
77643     } catch (std::exception& e) {
77644       {
77645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77646       };
77647     } catch (Dali::DaliException e) {
77648       {
77649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77650       };
77651     } catch (...) {
77652       {
77653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77654       };
77655     }
77656   }
77657
77658   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77659   return jresult;
77660 }
77661
77662
77663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77664   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77665   Dali::Toolkit::ItemRange *arg2 = 0 ;
77666
77667   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77668   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77669   if (!arg2) {
77670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77671     return ;
77672   }
77673   {
77674     try {
77675       (arg1)->GetItemsRange(*arg2);
77676     } catch (std::out_of_range& e) {
77677       {
77678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77679       };
77680     } catch (std::exception& e) {
77681       {
77682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77683       };
77684     } catch (Dali::DaliException e) {
77685       {
77686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77687       };
77688     } catch (...) {
77689       {
77690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77691       };
77692     }
77693   }
77694
77695 }
77696
77697
77698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77699   void * jresult ;
77700   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77701   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77702
77703   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77704   {
77705     try {
77706       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77707     } catch (std::out_of_range& e) {
77708       {
77709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77710       };
77711     } catch (std::exception& e) {
77712       {
77713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77714       };
77715     } catch (Dali::DaliException e) {
77716       {
77717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77718       };
77719     } catch (...) {
77720       {
77721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77722       };
77723     }
77724   }
77725
77726   jresult = (void *)result;
77727   return jresult;
77728 }
77729
77730
77731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77732   Dali::Vector3 *arg1 = 0 ;
77733   PropertyInputContainer *arg2 = 0 ;
77734
77735   arg1 = (Dali::Vector3 *)jarg1;
77736   if (!arg1) {
77737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77738     return ;
77739   }
77740   arg2 = (PropertyInputContainer *)jarg2;
77741   if (!arg2) {
77742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77743     return ;
77744   }
77745   {
77746     try {
77747       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77748     } catch (std::out_of_range& e) {
77749       {
77750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77751       };
77752     } catch (std::exception& e) {
77753       {
77754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77755       };
77756     } catch (Dali::DaliException e) {
77757       {
77758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77759       };
77760     } catch (...) {
77761       {
77762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77763       };
77764     }
77765   }
77766
77767 }
77768
77769
77770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77771   Dali::Vector3 *arg1 = 0 ;
77772   PropertyInputContainer *arg2 = 0 ;
77773
77774   arg1 = (Dali::Vector3 *)jarg1;
77775   if (!arg1) {
77776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77777     return ;
77778   }
77779   arg2 = (PropertyInputContainer *)jarg2;
77780   if (!arg2) {
77781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77782     return ;
77783   }
77784   {
77785     try {
77786       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77787     } catch (std::out_of_range& e) {
77788       {
77789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77790       };
77791     } catch (std::exception& e) {
77792       {
77793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77794       };
77795     } catch (Dali::DaliException e) {
77796       {
77797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77798       };
77799     } catch (...) {
77800       {
77801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77802       };
77803     }
77804   }
77805
77806 }
77807
77808
77809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77810   void * jresult ;
77811   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77812
77813   {
77814     try {
77815       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77816     } catch (std::out_of_range& e) {
77817       {
77818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77819       };
77820     } catch (std::exception& e) {
77821       {
77822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77823       };
77824     } catch (Dali::DaliException e) {
77825       {
77826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77827       };
77828     } catch (...) {
77829       {
77830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77831       };
77832     }
77833   }
77834
77835   jresult = (void *)result;
77836   return jresult;
77837 }
77838
77839
77840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77841   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77842
77843   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77844   {
77845     try {
77846       delete arg1;
77847     } catch (std::out_of_range& e) {
77848       {
77849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77850       };
77851     } catch (std::exception& e) {
77852       {
77853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77854       };
77855     } catch (Dali::DaliException e) {
77856       {
77857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77858       };
77859     } catch (...) {
77860       {
77861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77862       };
77863     }
77864   }
77865
77866 }
77867
77868
77869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77870   void * jresult ;
77871   Dali::Path arg1 ;
77872   Dali::Vector3 *arg2 = 0 ;
77873   Dali::Property::Index arg3 ;
77874   Dali::Vector3 *arg4 = 0 ;
77875   unsigned int arg5 ;
77876   Dali::Path *argp1 ;
77877   Dali::Toolkit::ScrollViewPagePathEffect result;
77878
77879   argp1 = (Dali::Path *)jarg1;
77880   if (!argp1) {
77881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77882     return 0;
77883   }
77884   arg1 = *argp1;
77885   arg2 = (Dali::Vector3 *)jarg2;
77886   if (!arg2) {
77887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77888     return 0;
77889   }
77890   arg3 = (Dali::Property::Index)jarg3;
77891   arg4 = (Dali::Vector3 *)jarg4;
77892   if (!arg4) {
77893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77894     return 0;
77895   }
77896   arg5 = (unsigned int)jarg5;
77897   {
77898     try {
77899       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77900     } catch (std::out_of_range& e) {
77901       {
77902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77903       };
77904     } catch (std::exception& e) {
77905       {
77906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77907       };
77908     } catch (Dali::DaliException e) {
77909       {
77910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77911       };
77912     } catch (...) {
77913       {
77914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77915       };
77916     }
77917   }
77918
77919   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77920   return jresult;
77921 }
77922
77923
77924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77925   void * jresult ;
77926   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77927
77928   {
77929     try {
77930       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77931     } catch (std::out_of_range& e) {
77932       {
77933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77934       };
77935     } catch (std::exception& e) {
77936       {
77937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77938       };
77939     } catch (Dali::DaliException e) {
77940       {
77941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77942       };
77943     } catch (...) {
77944       {
77945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77946       };
77947     }
77948   }
77949
77950   jresult = (void *)result;
77951   return jresult;
77952 }
77953
77954
77955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77956   void * jresult ;
77957   Dali::BaseHandle arg1 ;
77958   Dali::BaseHandle *argp1 ;
77959   Dali::Toolkit::ScrollViewPagePathEffect result;
77960
77961   argp1 = (Dali::BaseHandle *)jarg1;
77962   if (!argp1) {
77963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77964     return 0;
77965   }
77966   arg1 = *argp1;
77967   {
77968     try {
77969       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77970     } catch (std::out_of_range& e) {
77971       {
77972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77973       };
77974     } catch (std::exception& e) {
77975       {
77976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77977       };
77978     } catch (Dali::DaliException e) {
77979       {
77980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77981       };
77982     } catch (...) {
77983       {
77984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77985       };
77986     }
77987   }
77988
77989   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77990   return jresult;
77991 }
77992
77993
77994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77995   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77996   Dali::Actor arg2 ;
77997   unsigned int arg3 ;
77998   Dali::Actor *argp2 ;
77999
78000   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78001   argp2 = (Dali::Actor *)jarg2;
78002   if (!argp2) {
78003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78004     return ;
78005   }
78006   arg2 = *argp2;
78007   arg3 = (unsigned int)jarg3;
78008   {
78009     try {
78010       (arg1)->ApplyToPage(arg2,arg3);
78011     } catch (std::out_of_range& e) {
78012       {
78013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78014       };
78015     } catch (std::exception& e) {
78016       {
78017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78018       };
78019     } catch (Dali::DaliException e) {
78020       {
78021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78022       };
78023     } catch (...) {
78024       {
78025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78026       };
78027     }
78028   }
78029
78030 }
78031
78032
78033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
78034   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78035
78036   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78037   {
78038     try {
78039       delete arg1;
78040     } catch (std::out_of_range& e) {
78041       {
78042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78043       };
78044     } catch (std::exception& e) {
78045       {
78046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78047       };
78048     } catch (Dali::DaliException e) {
78049       {
78050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78051       };
78052     } catch (...) {
78053       {
78054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78055       };
78056     }
78057   }
78058
78059 }
78060
78061
78062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
78063   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78064   Dali::Toolkit::ClampState arg2 ;
78065
78066   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78067   arg2 = (Dali::Toolkit::ClampState)jarg2;
78068   if (arg1) (arg1)->x = arg2;
78069 }
78070
78071
78072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78073   int jresult ;
78074   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78075   Dali::Toolkit::ClampState result;
78076
78077   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78078   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78079   jresult = (int)result;
78080   return jresult;
78081 }
78082
78083
78084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78085   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78086   Dali::Toolkit::ClampState arg2 ;
78087
78088   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78089   arg2 = (Dali::Toolkit::ClampState)jarg2;
78090   if (arg1) (arg1)->y = arg2;
78091 }
78092
78093
78094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78095   int jresult ;
78096   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78097   Dali::Toolkit::ClampState result;
78098
78099   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78100   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78101   jresult = (int)result;
78102   return jresult;
78103 }
78104
78105
78106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78107   void * jresult ;
78108   Dali::Toolkit::ClampState2D *result = 0 ;
78109
78110   {
78111     try {
78112       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78113     } catch (std::out_of_range& e) {
78114       {
78115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78116       };
78117     } catch (std::exception& e) {
78118       {
78119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78120       };
78121     } catch (Dali::DaliException e) {
78122       {
78123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78124       };
78125     } catch (...) {
78126       {
78127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78128       };
78129     }
78130   }
78131
78132   jresult = (void *)result;
78133   return jresult;
78134 }
78135
78136
78137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78138   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78139
78140   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78141   {
78142     try {
78143       delete arg1;
78144     } catch (std::out_of_range& e) {
78145       {
78146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78147       };
78148     } catch (std::exception& e) {
78149       {
78150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78151       };
78152     } catch (Dali::DaliException e) {
78153       {
78154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78155       };
78156     } catch (...) {
78157       {
78158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78159       };
78160     }
78161   }
78162
78163 }
78164
78165
78166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78167   void * jresult ;
78168   float arg1 ;
78169   float arg2 ;
78170   bool arg3 ;
78171   Dali::Toolkit::RulerDomain *result = 0 ;
78172
78173   arg1 = (float)jarg1;
78174   arg2 = (float)jarg2;
78175   arg3 = jarg3 ? true : false;
78176   {
78177     try {
78178       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
78179     } catch (std::out_of_range& e) {
78180       {
78181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78182       };
78183     } catch (std::exception& e) {
78184       {
78185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78186       };
78187     } catch (Dali::DaliException e) {
78188       {
78189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78190       };
78191     } catch (...) {
78192       {
78193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78194       };
78195     }
78196   }
78197
78198   jresult = (void *)result;
78199   return jresult;
78200 }
78201
78202
78203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78204   void * jresult ;
78205   float arg1 ;
78206   float arg2 ;
78207   Dali::Toolkit::RulerDomain *result = 0 ;
78208
78209   arg1 = (float)jarg1;
78210   arg2 = (float)jarg2;
78211   {
78212     try {
78213       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78214     } catch (std::out_of_range& e) {
78215       {
78216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78217       };
78218     } catch (std::exception& e) {
78219       {
78220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78221       };
78222     } catch (Dali::DaliException e) {
78223       {
78224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78225       };
78226     } catch (...) {
78227       {
78228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78229       };
78230     }
78231   }
78232
78233   jresult = (void *)result;
78234   return jresult;
78235 }
78236
78237
78238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78239   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78240   float arg2 ;
78241
78242   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78243   arg2 = (float)jarg2;
78244   if (arg1) (arg1)->min = arg2;
78245 }
78246
78247
78248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78249   float jresult ;
78250   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78251   float result;
78252
78253   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78254   result = (float) ((arg1)->min);
78255   jresult = result;
78256   return jresult;
78257 }
78258
78259
78260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78261   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78262   float arg2 ;
78263
78264   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78265   arg2 = (float)jarg2;
78266   if (arg1) (arg1)->max = arg2;
78267 }
78268
78269
78270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78271   float jresult ;
78272   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78273   float result;
78274
78275   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78276   result = (float) ((arg1)->max);
78277   jresult = result;
78278   return jresult;
78279 }
78280
78281
78282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78283   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78284   bool arg2 ;
78285
78286   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78287   arg2 = jarg2 ? true : false;
78288   if (arg1) (arg1)->enabled = arg2;
78289 }
78290
78291
78292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78293   unsigned int jresult ;
78294   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78295   bool result;
78296
78297   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78298   result = (bool) ((arg1)->enabled);
78299   jresult = result;
78300   return jresult;
78301 }
78302
78303
78304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78305   float jresult ;
78306   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78307   float arg2 ;
78308   float arg3 ;
78309   float arg4 ;
78310   float result;
78311
78312   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78313   arg2 = (float)jarg2;
78314   arg3 = (float)jarg3;
78315   arg4 = (float)jarg4;
78316   {
78317     try {
78318       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78319     } catch (std::out_of_range& e) {
78320       {
78321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78322       };
78323     } catch (std::exception& e) {
78324       {
78325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78326       };
78327     } catch (Dali::DaliException e) {
78328       {
78329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78330       };
78331     } catch (...) {
78332       {
78333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78334       };
78335     }
78336   }
78337
78338   jresult = result;
78339   return jresult;
78340 }
78341
78342
78343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78344   float jresult ;
78345   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78346   float arg2 ;
78347   float arg3 ;
78348   float result;
78349
78350   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78351   arg2 = (float)jarg2;
78352   arg3 = (float)jarg3;
78353   {
78354     try {
78355       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78356     } catch (std::out_of_range& e) {
78357       {
78358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78359       };
78360     } catch (std::exception& e) {
78361       {
78362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78363       };
78364     } catch (Dali::DaliException e) {
78365       {
78366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78367       };
78368     } catch (...) {
78369       {
78370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78371       };
78372     }
78373   }
78374
78375   jresult = result;
78376   return jresult;
78377 }
78378
78379
78380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78381   float jresult ;
78382   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78383   float arg2 ;
78384   float result;
78385
78386   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78387   arg2 = (float)jarg2;
78388   {
78389     try {
78390       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78391     } catch (std::out_of_range& e) {
78392       {
78393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78394       };
78395     } catch (std::exception& e) {
78396       {
78397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78398       };
78399     } catch (Dali::DaliException e) {
78400       {
78401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78402       };
78403     } catch (...) {
78404       {
78405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78406       };
78407     }
78408   }
78409
78410   jresult = result;
78411   return jresult;
78412 }
78413
78414
78415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78416   float jresult ;
78417   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78418   float arg2 ;
78419   float arg3 ;
78420   float arg4 ;
78421   Dali::Toolkit::ClampState *arg5 = 0 ;
78422   float result;
78423
78424   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78425   arg2 = (float)jarg2;
78426   arg3 = (float)jarg3;
78427   arg4 = (float)jarg4;
78428   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78429   if (!arg5) {
78430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78431     return 0;
78432   }
78433   {
78434     try {
78435       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78436     } catch (std::out_of_range& e) {
78437       {
78438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78439       };
78440     } catch (std::exception& e) {
78441       {
78442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78443       };
78444     } catch (Dali::DaliException e) {
78445       {
78446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78447       };
78448     } catch (...) {
78449       {
78450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78451       };
78452     }
78453   }
78454
78455   jresult = result;
78456   return jresult;
78457 }
78458
78459
78460 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78461   float jresult ;
78462   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78463   float result;
78464
78465   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78466   {
78467     try {
78468       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78469     } catch (std::out_of_range& e) {
78470       {
78471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78472       };
78473     } catch (std::exception& e) {
78474       {
78475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78476       };
78477     } catch (Dali::DaliException e) {
78478       {
78479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78480       };
78481     } catch (...) {
78482       {
78483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78484       };
78485     }
78486   }
78487
78488   jresult = result;
78489   return jresult;
78490 }
78491
78492
78493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78494   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78495
78496   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78497   {
78498     try {
78499       delete arg1;
78500     } catch (std::out_of_range& e) {
78501       {
78502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78503       };
78504     } catch (std::exception& e) {
78505       {
78506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78507       };
78508     } catch (Dali::DaliException e) {
78509       {
78510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78511       };
78512     } catch (...) {
78513       {
78514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78515       };
78516     }
78517   }
78518
78519 }
78520
78521
78522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78523   float jresult ;
78524   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78525   float arg2 ;
78526   float arg3 ;
78527   float result;
78528
78529   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78530   arg2 = (float)jarg2;
78531   arg3 = (float)jarg3;
78532   {
78533     try {
78534       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78535     } catch (std::out_of_range& e) {
78536       {
78537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78538       };
78539     } catch (std::exception& e) {
78540       {
78541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78542       };
78543     } catch (Dali::DaliException e) {
78544       {
78545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78546       };
78547     } catch (...) {
78548       {
78549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78550       };
78551     }
78552   }
78553
78554   jresult = result;
78555   return jresult;
78556 }
78557
78558
78559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78560   float jresult ;
78561   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78562   float arg2 ;
78563   float result;
78564
78565   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78566   arg2 = (float)jarg2;
78567   {
78568     try {
78569       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78570     } catch (std::out_of_range& e) {
78571       {
78572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78573       };
78574     } catch (std::exception& e) {
78575       {
78576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78577       };
78578     } catch (Dali::DaliException e) {
78579       {
78580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78581       };
78582     } catch (...) {
78583       {
78584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78585       };
78586     }
78587   }
78588
78589   jresult = result;
78590   return jresult;
78591 }
78592
78593
78594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78595   float jresult ;
78596   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78597   unsigned int arg2 ;
78598   unsigned int *arg3 = 0 ;
78599   bool arg4 ;
78600   float result;
78601
78602   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78603   arg2 = (unsigned int)jarg2;
78604   arg3 = (unsigned int *)jarg3;
78605   arg4 = jarg4 ? true : false;
78606   {
78607     try {
78608       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78609     } catch (std::out_of_range& e) {
78610       {
78611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78612       };
78613     } catch (std::exception& e) {
78614       {
78615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78616       };
78617     } catch (Dali::DaliException e) {
78618       {
78619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78620       };
78621     } catch (...) {
78622       {
78623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78624       };
78625     }
78626   }
78627
78628   jresult = result;
78629   return jresult;
78630 }
78631
78632
78633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78634   unsigned int jresult ;
78635   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78636   float arg2 ;
78637   bool arg3 ;
78638   unsigned int result;
78639
78640   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78641   arg2 = (float)jarg2;
78642   arg3 = jarg3 ? true : false;
78643   {
78644     try {
78645       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78646     } catch (std::out_of_range& e) {
78647       {
78648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78649       };
78650     } catch (std::exception& e) {
78651       {
78652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78653       };
78654     } catch (Dali::DaliException e) {
78655       {
78656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78657       };
78658     } catch (...) {
78659       {
78660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78661       };
78662     }
78663   }
78664
78665   jresult = result;
78666   return jresult;
78667 }
78668
78669
78670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78671   unsigned int jresult ;
78672   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78673   unsigned int result;
78674
78675   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78676   {
78677     try {
78678       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78679     } catch (std::out_of_range& e) {
78680       {
78681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78682       };
78683     } catch (std::exception& e) {
78684       {
78685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78686       };
78687     } catch (Dali::DaliException e) {
78688       {
78689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78690       };
78691     } catch (...) {
78692       {
78693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78694       };
78695     }
78696   }
78697
78698   jresult = result;
78699   return jresult;
78700 }
78701
78702
78703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78704   int jresult ;
78705   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78706   Dali::Toolkit::Ruler::RulerType result;
78707
78708   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78709   {
78710     try {
78711       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78712     } catch (std::out_of_range& e) {
78713       {
78714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78715       };
78716     } catch (std::exception& e) {
78717       {
78718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78719       };
78720     } catch (Dali::DaliException e) {
78721       {
78722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78723       };
78724     } catch (...) {
78725       {
78726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78727       };
78728     }
78729   }
78730
78731   jresult = (int)result;
78732   return jresult;
78733 }
78734
78735
78736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78737   unsigned int jresult ;
78738   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78739   bool result;
78740
78741   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78742   {
78743     try {
78744       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78745     } catch (std::out_of_range& e) {
78746       {
78747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78748       };
78749     } catch (std::exception& e) {
78750       {
78751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78752       };
78753     } catch (Dali::DaliException e) {
78754       {
78755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78756       };
78757     } catch (...) {
78758       {
78759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78760       };
78761     }
78762   }
78763
78764   jresult = result;
78765   return jresult;
78766 }
78767
78768
78769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78770   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78771
78772   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78773   {
78774     try {
78775       (arg1)->Enable();
78776     } catch (std::out_of_range& e) {
78777       {
78778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78779       };
78780     } catch (std::exception& e) {
78781       {
78782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78783       };
78784     } catch (Dali::DaliException e) {
78785       {
78786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78787       };
78788     } catch (...) {
78789       {
78790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78791       };
78792     }
78793   }
78794
78795 }
78796
78797
78798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78799   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78800
78801   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78802   {
78803     try {
78804       (arg1)->Disable();
78805     } catch (std::out_of_range& e) {
78806       {
78807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78808       };
78809     } catch (std::exception& e) {
78810       {
78811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78812       };
78813     } catch (Dali::DaliException e) {
78814       {
78815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78816       };
78817     } catch (...) {
78818       {
78819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78820       };
78821     }
78822   }
78823
78824 }
78825
78826
78827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78828   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78829   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78830   Dali::Toolkit::RulerDomain *argp2 ;
78831
78832   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78833   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78834   if (!argp2) {
78835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78836     return ;
78837   }
78838   arg2 = *argp2;
78839   {
78840     try {
78841       (arg1)->SetDomain(arg2);
78842     } catch (std::out_of_range& e) {
78843       {
78844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78845       };
78846     } catch (std::exception& e) {
78847       {
78848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78849       };
78850     } catch (Dali::DaliException e) {
78851       {
78852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78853       };
78854     } catch (...) {
78855       {
78856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78857       };
78858     }
78859   }
78860
78861 }
78862
78863
78864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78865   void * jresult ;
78866   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78867   Dali::Toolkit::RulerDomain *result = 0 ;
78868
78869   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78870   {
78871     try {
78872       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78873     } catch (std::out_of_range& e) {
78874       {
78875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78876       };
78877     } catch (std::exception& e) {
78878       {
78879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78880       };
78881     } catch (Dali::DaliException e) {
78882       {
78883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78884       };
78885     } catch (...) {
78886       {
78887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78888       };
78889     }
78890   }
78891
78892   jresult = (void *)result;
78893   return jresult;
78894 }
78895
78896
78897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78898   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78899
78900   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78901   {
78902     try {
78903       (arg1)->DisableDomain();
78904     } catch (std::out_of_range& e) {
78905       {
78906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78907       };
78908     } catch (std::exception& e) {
78909       {
78910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78911       };
78912     } catch (Dali::DaliException e) {
78913       {
78914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78915       };
78916     } catch (...) {
78917       {
78918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78919       };
78920     }
78921   }
78922
78923 }
78924
78925
78926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78927   float jresult ;
78928   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78929   float arg2 ;
78930   float arg3 ;
78931   float arg4 ;
78932   float result;
78933
78934   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78935   arg2 = (float)jarg2;
78936   arg3 = (float)jarg3;
78937   arg4 = (float)jarg4;
78938   {
78939     try {
78940       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78941     } catch (std::out_of_range& e) {
78942       {
78943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78944       };
78945     } catch (std::exception& e) {
78946       {
78947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78948       };
78949     } catch (Dali::DaliException e) {
78950       {
78951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78952       };
78953     } catch (...) {
78954       {
78955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78956       };
78957     }
78958   }
78959
78960   jresult = result;
78961   return jresult;
78962 }
78963
78964
78965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78966   float jresult ;
78967   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78968   float arg2 ;
78969   float arg3 ;
78970   float result;
78971
78972   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78973   arg2 = (float)jarg2;
78974   arg3 = (float)jarg3;
78975   {
78976     try {
78977       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78978     } catch (std::out_of_range& e) {
78979       {
78980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78981       };
78982     } catch (std::exception& e) {
78983       {
78984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78985       };
78986     } catch (Dali::DaliException e) {
78987       {
78988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78989       };
78990     } catch (...) {
78991       {
78992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78993       };
78994     }
78995   }
78996
78997   jresult = result;
78998   return jresult;
78999 }
79000
79001
79002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
79003   float jresult ;
79004   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79005   float arg2 ;
79006   float result;
79007
79008   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79009   arg2 = (float)jarg2;
79010   {
79011     try {
79012       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
79013     } catch (std::out_of_range& e) {
79014       {
79015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79016       };
79017     } catch (std::exception& e) {
79018       {
79019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79020       };
79021     } catch (Dali::DaliException e) {
79022       {
79023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79024       };
79025     } catch (...) {
79026       {
79027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79028       };
79029     }
79030   }
79031
79032   jresult = result;
79033   return jresult;
79034 }
79035
79036
79037 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
79038   float jresult ;
79039   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79040   float arg2 ;
79041   float arg3 ;
79042   float arg4 ;
79043   Dali::Toolkit::ClampState *arg5 = 0 ;
79044   float result;
79045
79046   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79047   arg2 = (float)jarg2;
79048   arg3 = (float)jarg3;
79049   arg4 = (float)jarg4;
79050   arg5 = (Dali::Toolkit::ClampState *)jarg5;
79051   if (!arg5) {
79052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79053     return 0;
79054   }
79055   {
79056     try {
79057       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
79058     } catch (std::out_of_range& e) {
79059       {
79060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79061       };
79062     } catch (std::exception& e) {
79063       {
79064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79065       };
79066     } catch (Dali::DaliException e) {
79067       {
79068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79069       };
79070     } catch (...) {
79071       {
79072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79073       };
79074     }
79075   }
79076
79077   jresult = result;
79078   return jresult;
79079 }
79080
79081
79082 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79083   float jresult ;
79084   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79085   float arg2 ;
79086   float arg3 ;
79087   float arg4 ;
79088   float arg5 ;
79089   float result;
79090
79091   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79092   arg2 = (float)jarg2;
79093   arg3 = (float)jarg3;
79094   arg4 = (float)jarg4;
79095   arg5 = (float)jarg5;
79096   {
79097     try {
79098       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79099     } catch (std::out_of_range& e) {
79100       {
79101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79102       };
79103     } catch (std::exception& e) {
79104       {
79105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79106       };
79107     } catch (Dali::DaliException e) {
79108       {
79109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79110       };
79111     } catch (...) {
79112       {
79113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79114       };
79115     }
79116   }
79117
79118   jresult = result;
79119   return jresult;
79120 }
79121
79122
79123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79124   float jresult ;
79125   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79126   float arg2 ;
79127   float arg3 ;
79128   float arg4 ;
79129   float result;
79130
79131   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79132   arg2 = (float)jarg2;
79133   arg3 = (float)jarg3;
79134   arg4 = (float)jarg4;
79135   {
79136     try {
79137       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79138     } catch (std::out_of_range& e) {
79139       {
79140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79141       };
79142     } catch (std::exception& e) {
79143       {
79144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79145       };
79146     } catch (Dali::DaliException e) {
79147       {
79148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79149       };
79150     } catch (...) {
79151       {
79152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79153       };
79154     }
79155   }
79156
79157   jresult = result;
79158   return jresult;
79159 }
79160
79161
79162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79163   float jresult ;
79164   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79165   float arg2 ;
79166   float arg3 ;
79167   float result;
79168
79169   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79170   arg2 = (float)jarg2;
79171   arg3 = (float)jarg3;
79172   {
79173     try {
79174       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
79175     } catch (std::out_of_range& e) {
79176       {
79177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79178       };
79179     } catch (std::exception& e) {
79180       {
79181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79182       };
79183     } catch (Dali::DaliException e) {
79184       {
79185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79186       };
79187     } catch (...) {
79188       {
79189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79190       };
79191     }
79192   }
79193
79194   jresult = result;
79195   return jresult;
79196 }
79197
79198
79199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
79200   float jresult ;
79201   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79202   float arg2 ;
79203   float result;
79204
79205   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79206   arg2 = (float)jarg2;
79207   {
79208     try {
79209       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79210     } catch (std::out_of_range& e) {
79211       {
79212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79213       };
79214     } catch (std::exception& e) {
79215       {
79216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79217       };
79218     } catch (Dali::DaliException e) {
79219       {
79220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79221       };
79222     } catch (...) {
79223       {
79224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79225       };
79226     }
79227   }
79228
79229   jresult = result;
79230   return jresult;
79231 }
79232
79233
79234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79235   float jresult ;
79236   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79237   float arg2 ;
79238   float arg3 ;
79239   float arg4 ;
79240   float arg5 ;
79241   Dali::Toolkit::ClampState *arg6 = 0 ;
79242   float result;
79243
79244   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79245   arg2 = (float)jarg2;
79246   arg3 = (float)jarg3;
79247   arg4 = (float)jarg4;
79248   arg5 = (float)jarg5;
79249   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79250   if (!arg6) {
79251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79252     return 0;
79253   }
79254   {
79255     try {
79256       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79257     } catch (std::out_of_range& e) {
79258       {
79259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79260       };
79261     } catch (std::exception& e) {
79262       {
79263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79264       };
79265     } catch (Dali::DaliException e) {
79266       {
79267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79268       };
79269     } catch (...) {
79270       {
79271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79272       };
79273     }
79274   }
79275
79276   jresult = result;
79277   return jresult;
79278 }
79279
79280
79281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79282   void * jresult ;
79283   Dali::Toolkit::DefaultRuler *result = 0 ;
79284
79285   {
79286     try {
79287       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79288     } catch (std::out_of_range& e) {
79289       {
79290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79291       };
79292     } catch (std::exception& e) {
79293       {
79294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79295       };
79296     } catch (Dali::DaliException e) {
79297       {
79298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79299       };
79300     } catch (...) {
79301       {
79302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79303       };
79304     }
79305   }
79306
79307   jresult = (void *)result;
79308   return jresult;
79309 }
79310
79311
79312 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79313   float jresult ;
79314   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79315   float arg2 ;
79316   float arg3 ;
79317   float result;
79318
79319   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79320   arg2 = (float)jarg2;
79321   arg3 = (float)jarg3;
79322   {
79323     try {
79324       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79325     } catch (std::out_of_range& e) {
79326       {
79327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79328       };
79329     } catch (std::exception& e) {
79330       {
79331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79332       };
79333     } catch (Dali::DaliException e) {
79334       {
79335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79336       };
79337     } catch (...) {
79338       {
79339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79340       };
79341     }
79342   }
79343
79344   jresult = result;
79345   return jresult;
79346 }
79347
79348
79349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79350   float jresult ;
79351   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79352   unsigned int arg2 ;
79353   unsigned int *arg3 = 0 ;
79354   bool arg4 ;
79355   float result;
79356
79357   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79358   arg2 = (unsigned int)jarg2;
79359   arg3 = (unsigned int *)jarg3;
79360   arg4 = jarg4 ? true : false;
79361   {
79362     try {
79363       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79364     } catch (std::out_of_range& e) {
79365       {
79366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79367       };
79368     } catch (std::exception& e) {
79369       {
79370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79371       };
79372     } catch (Dali::DaliException e) {
79373       {
79374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79375       };
79376     } catch (...) {
79377       {
79378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79379       };
79380     }
79381   }
79382
79383   jresult = result;
79384   return jresult;
79385 }
79386
79387
79388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79389   unsigned int jresult ;
79390   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79391   float arg2 ;
79392   bool arg3 ;
79393   unsigned int result;
79394
79395   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79396   arg2 = (float)jarg2;
79397   arg3 = jarg3 ? true : false;
79398   {
79399     try {
79400       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79401     } catch (std::out_of_range& e) {
79402       {
79403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79404       };
79405     } catch (std::exception& e) {
79406       {
79407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79408       };
79409     } catch (Dali::DaliException e) {
79410       {
79411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79412       };
79413     } catch (...) {
79414       {
79415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79416       };
79417     }
79418   }
79419
79420   jresult = result;
79421   return jresult;
79422 }
79423
79424
79425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79426   unsigned int jresult ;
79427   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79428   unsigned int result;
79429
79430   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79431   {
79432     try {
79433       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79434     } catch (std::out_of_range& e) {
79435       {
79436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79437       };
79438     } catch (std::exception& e) {
79439       {
79440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79441       };
79442     } catch (Dali::DaliException e) {
79443       {
79444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79445       };
79446     } catch (...) {
79447       {
79448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79449       };
79450     }
79451   }
79452
79453   jresult = result;
79454   return jresult;
79455 }
79456
79457
79458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79459   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79460
79461   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79462   {
79463     try {
79464       delete arg1;
79465     } catch (std::out_of_range& e) {
79466       {
79467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79468       };
79469     } catch (std::exception& e) {
79470       {
79471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79472       };
79473     } catch (Dali::DaliException e) {
79474       {
79475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79476       };
79477     } catch (...) {
79478       {
79479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79480       };
79481     }
79482   }
79483
79484 }
79485
79486
79487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79488   void * jresult ;
79489   float arg1 ;
79490   Dali::Toolkit::FixedRuler *result = 0 ;
79491
79492   arg1 = (float)jarg1;
79493   {
79494     try {
79495       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79496     } catch (std::out_of_range& e) {
79497       {
79498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79499       };
79500     } catch (std::exception& e) {
79501       {
79502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79503       };
79504     } catch (Dali::DaliException e) {
79505       {
79506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79507       };
79508     } catch (...) {
79509       {
79510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79511       };
79512     }
79513   }
79514
79515   jresult = (void *)result;
79516   return jresult;
79517 }
79518
79519
79520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79521   void * jresult ;
79522   Dali::Toolkit::FixedRuler *result = 0 ;
79523
79524   {
79525     try {
79526       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79527     } catch (std::out_of_range& e) {
79528       {
79529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79530       };
79531     } catch (std::exception& e) {
79532       {
79533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79534       };
79535     } catch (Dali::DaliException e) {
79536       {
79537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79538       };
79539     } catch (...) {
79540       {
79541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79542       };
79543     }
79544   }
79545
79546   jresult = (void *)result;
79547   return jresult;
79548 }
79549
79550
79551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79552   float jresult ;
79553   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79554   float arg2 ;
79555   float arg3 ;
79556   float result;
79557
79558   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79559   arg2 = (float)jarg2;
79560   arg3 = (float)jarg3;
79561   {
79562     try {
79563       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79564     } catch (std::out_of_range& e) {
79565       {
79566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79567       };
79568     } catch (std::exception& e) {
79569       {
79570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79571       };
79572     } catch (Dali::DaliException e) {
79573       {
79574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79575       };
79576     } catch (...) {
79577       {
79578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79579       };
79580     }
79581   }
79582
79583   jresult = result;
79584   return jresult;
79585 }
79586
79587
79588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79589   float jresult ;
79590   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79591   unsigned int arg2 ;
79592   unsigned int *arg3 = 0 ;
79593   bool arg4 ;
79594   float result;
79595
79596   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79597   arg2 = (unsigned int)jarg2;
79598   arg3 = (unsigned int *)jarg3;
79599   arg4 = jarg4 ? true : false;
79600   {
79601     try {
79602       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79603     } catch (std::out_of_range& e) {
79604       {
79605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79606       };
79607     } catch (std::exception& e) {
79608       {
79609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79610       };
79611     } catch (Dali::DaliException e) {
79612       {
79613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79614       };
79615     } catch (...) {
79616       {
79617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79618       };
79619     }
79620   }
79621
79622   jresult = result;
79623   return jresult;
79624 }
79625
79626
79627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79628   unsigned int jresult ;
79629   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79630   float arg2 ;
79631   bool arg3 ;
79632   unsigned int result;
79633
79634   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79635   arg2 = (float)jarg2;
79636   arg3 = jarg3 ? true : false;
79637   {
79638     try {
79639       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79640     } catch (std::out_of_range& e) {
79641       {
79642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79643       };
79644     } catch (std::exception& e) {
79645       {
79646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79647       };
79648     } catch (Dali::DaliException e) {
79649       {
79650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79651       };
79652     } catch (...) {
79653       {
79654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79655       };
79656     }
79657   }
79658
79659   jresult = result;
79660   return jresult;
79661 }
79662
79663
79664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79665   unsigned int jresult ;
79666   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79667   unsigned int result;
79668
79669   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79670   {
79671     try {
79672       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79673     } catch (std::out_of_range& e) {
79674       {
79675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79676       };
79677     } catch (std::exception& e) {
79678       {
79679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79680       };
79681     } catch (Dali::DaliException e) {
79682       {
79683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79684       };
79685     } catch (...) {
79686       {
79687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79688       };
79689     }
79690   }
79691
79692   jresult = result;
79693   return jresult;
79694 }
79695
79696
79697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79698   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79699
79700   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79701   {
79702     try {
79703       delete arg1;
79704     } catch (std::out_of_range& e) {
79705       {
79706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79707       };
79708     } catch (std::exception& e) {
79709       {
79710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79711       };
79712     } catch (Dali::DaliException e) {
79713       {
79714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79715       };
79716     } catch (...) {
79717       {
79718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79719       };
79720     }
79721   }
79722
79723 }
79724
79725
79726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79727   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79728   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79729
79730   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79731   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79732   if (arg1) (arg1)->scale = *arg2;
79733 }
79734
79735
79736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79737   void * jresult ;
79738   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79739   Dali::Toolkit::ClampState2D *result = 0 ;
79740
79741   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79742   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79743   jresult = (void *)result;
79744   return jresult;
79745 }
79746
79747
79748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79749   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79750   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79751
79752   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79753   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79754   if (arg1) (arg1)->position = *arg2;
79755 }
79756
79757
79758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79759   void * jresult ;
79760   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79761   Dali::Toolkit::ClampState2D *result = 0 ;
79762
79763   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79764   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79765   jresult = (void *)result;
79766   return jresult;
79767 }
79768
79769
79770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79771   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79772   Dali::Toolkit::ClampState arg2 ;
79773
79774   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79775   arg2 = (Dali::Toolkit::ClampState)jarg2;
79776   if (arg1) (arg1)->rotation = arg2;
79777 }
79778
79779
79780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79781   int jresult ;
79782   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79783   Dali::Toolkit::ClampState result;
79784
79785   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79786   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79787   jresult = (int)result;
79788   return jresult;
79789 }
79790
79791
79792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79793   void * jresult ;
79794   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79795
79796   {
79797     try {
79798       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79799     } catch (std::out_of_range& e) {
79800       {
79801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79802       };
79803     } catch (std::exception& e) {
79804       {
79805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79806       };
79807     } catch (Dali::DaliException e) {
79808       {
79809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79810       };
79811     } catch (...) {
79812       {
79813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79814       };
79815     }
79816   }
79817
79818   jresult = (void *)result;
79819   return jresult;
79820 }
79821
79822
79823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79824   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79825
79826   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79827   {
79828     try {
79829       delete arg1;
79830     } catch (std::out_of_range& e) {
79831       {
79832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79833       };
79834     } catch (std::exception& e) {
79835       {
79836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79837       };
79838     } catch (Dali::DaliException e) {
79839       {
79840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79841       };
79842     } catch (...) {
79843       {
79844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79845       };
79846     }
79847   }
79848
79849 }
79850
79851
79852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79853   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79854   Dali::Toolkit::SnapType arg2 ;
79855
79856   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79857   arg2 = (Dali::Toolkit::SnapType)jarg2;
79858   if (arg1) (arg1)->type = arg2;
79859 }
79860
79861
79862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79863   int jresult ;
79864   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79865   Dali::Toolkit::SnapType result;
79866
79867   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79868   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79869   jresult = (int)result;
79870   return jresult;
79871 }
79872
79873
79874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79875   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79876   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79877
79878   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79879   arg2 = (Dali::Vector2 *)jarg2;
79880   if (arg1) (arg1)->position = *arg2;
79881 }
79882
79883
79884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79885   void * jresult ;
79886   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79887   Dali::Vector2 *result = 0 ;
79888
79889   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79890   result = (Dali::Vector2 *)& ((arg1)->position);
79891   jresult = (void *)result;
79892   return jresult;
79893 }
79894
79895
79896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79897   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79898   float arg2 ;
79899
79900   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79901   arg2 = (float)jarg2;
79902   if (arg1) (arg1)->duration = arg2;
79903 }
79904
79905
79906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79907   float jresult ;
79908   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79909   float result;
79910
79911   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79912   result = (float) ((arg1)->duration);
79913   jresult = result;
79914   return jresult;
79915 }
79916
79917
79918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79919   void * jresult ;
79920   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79921
79922   {
79923     try {
79924       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79925     } catch (std::out_of_range& e) {
79926       {
79927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79928       };
79929     } catch (std::exception& e) {
79930       {
79931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79932       };
79933     } catch (Dali::DaliException e) {
79934       {
79935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79936       };
79937     } catch (...) {
79938       {
79939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79940       };
79941     }
79942   }
79943
79944   jresult = (void *)result;
79945   return jresult;
79946 }
79947
79948
79949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79950   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79951
79952   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79953   {
79954     try {
79955       delete arg1;
79956     } catch (std::out_of_range& e) {
79957       {
79958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79959       };
79960     } catch (std::exception& e) {
79961       {
79962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79963       };
79964     } catch (Dali::DaliException e) {
79965       {
79966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79967       };
79968     } catch (...) {
79969       {
79970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79971       };
79972     }
79973   }
79974
79975 }
79976
79977
79978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79979   int jresult ;
79980   int result;
79981
79982   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79983   jresult = (int)result;
79984   return jresult;
79985 }
79986
79987
79988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79989   int jresult ;
79990   int result;
79991
79992   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79993   jresult = (int)result;
79994   return jresult;
79995 }
79996
79997
79998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79999   int jresult ;
80000   int result;
80001
80002   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
80003   jresult = (int)result;
80004   return jresult;
80005 }
80006
80007
80008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
80009   int jresult ;
80010   int result;
80011
80012   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
80013   jresult = (int)result;
80014   return jresult;
80015 }
80016
80017
80018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
80019   int jresult ;
80020   int result;
80021
80022   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
80023   jresult = (int)result;
80024   return jresult;
80025 }
80026
80027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
80028   int jresult ;
80029   int result;
80030
80031   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
80032   jresult = (int)result;
80033   return jresult;
80034 }
80035
80036
80037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
80038   int jresult ;
80039   int result;
80040
80041   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
80042   jresult = (int)result;
80043   return jresult;
80044 }
80045
80046
80047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
80048   int jresult ;
80049   int result;
80050
80051   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
80052   jresult = (int)result;
80053   return jresult;
80054 }
80055
80056
80057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
80058   int jresult ;
80059   int result;
80060
80061   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
80062   jresult = (int)result;
80063   return jresult;
80064 }
80065
80066
80067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
80068   int jresult ;
80069   int result;
80070
80071   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80072   jresult = (int)result;
80073   return jresult;
80074 }
80075
80076
80077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80078   int jresult ;
80079   int result;
80080
80081   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80082   jresult = (int)result;
80083   return jresult;
80084 }
80085
80086
80087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80088   int jresult ;
80089   int result;
80090
80091   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80092   jresult = (int)result;
80093   return jresult;
80094 }
80095
80096
80097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80098   int jresult ;
80099   int result;
80100
80101   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80102   jresult = (int)result;
80103   return jresult;
80104 }
80105
80106
80107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80108   int jresult ;
80109   int result;
80110
80111   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80112   jresult = (int)result;
80113   return jresult;
80114 }
80115
80116
80117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80118   int jresult ;
80119   int result;
80120
80121   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80122   jresult = (int)result;
80123   return jresult;
80124 }
80125
80126
80127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80128   int jresult ;
80129   int result;
80130
80131   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80132   jresult = (int)result;
80133   return jresult;
80134 }
80135
80136
80137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80138   int jresult ;
80139   int result;
80140
80141   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80142   jresult = (int)result;
80143   return jresult;
80144 }
80145
80146
80147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80148   int jresult ;
80149   int result;
80150
80151   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80152   jresult = (int)result;
80153   return jresult;
80154 }
80155
80156
80157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80158   int jresult ;
80159   int result;
80160
80161   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80162   jresult = (int)result;
80163   return jresult;
80164 }
80165
80166
80167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80168   int jresult ;
80169   int result;
80170
80171   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80172   jresult = (int)result;
80173   return jresult;
80174 }
80175
80176
80177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80178   int jresult ;
80179   int result;
80180
80181   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80182   jresult = (int)result;
80183   return jresult;
80184 }
80185
80186
80187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80188   int jresult ;
80189   int result;
80190
80191   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80192   jresult = (int)result;
80193   return jresult;
80194 }
80195
80196
80197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80198   int jresult ;
80199   int result;
80200
80201   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80202   jresult = (int)result;
80203   return jresult;
80204 }
80205
80206
80207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80208   int jresult ;
80209   int result;
80210
80211   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80212   jresult = (int)result;
80213   return jresult;
80214 }
80215
80216
80217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80218   int jresult ;
80219   int result;
80220
80221   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80222   jresult = (int)result;
80223   return jresult;
80224 }
80225
80226
80227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80228   int jresult ;
80229   int result;
80230
80231   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80232   jresult = (int)result;
80233   return jresult;
80234 }
80235
80236
80237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80238   void * jresult ;
80239   Dali::Toolkit::ScrollView::Property *result = 0 ;
80240
80241   {
80242     try {
80243       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80244     } catch (std::out_of_range& e) {
80245       {
80246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80247       };
80248     } catch (std::exception& e) {
80249       {
80250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80251       };
80252     } catch (Dali::DaliException e) {
80253       {
80254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80255       };
80256     } catch (...) {
80257       {
80258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80259       };
80260     }
80261   }
80262
80263   jresult = (void *)result;
80264   return jresult;
80265 }
80266
80267
80268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80269   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80270
80271   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80272   {
80273     try {
80274       delete arg1;
80275     } catch (std::out_of_range& e) {
80276       {
80277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80278       };
80279     } catch (std::exception& e) {
80280       {
80281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80282       };
80283     } catch (Dali::DaliException e) {
80284       {
80285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80286       };
80287     } catch (...) {
80288       {
80289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80290       };
80291     }
80292   }
80293
80294 }
80295
80296
80297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80298   void * jresult ;
80299   Dali::Toolkit::ScrollView *result = 0 ;
80300
80301   {
80302     try {
80303       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80304     } catch (std::out_of_range& e) {
80305       {
80306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80307       };
80308     } catch (std::exception& e) {
80309       {
80310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80311       };
80312     } catch (Dali::DaliException e) {
80313       {
80314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80315       };
80316     } catch (...) {
80317       {
80318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80319       };
80320     }
80321   }
80322
80323   jresult = (void *)result;
80324   return jresult;
80325 }
80326
80327
80328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80329   void * jresult ;
80330   Dali::Toolkit::ScrollView *arg1 = 0 ;
80331   Dali::Toolkit::ScrollView *result = 0 ;
80332
80333   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80334   if (!arg1) {
80335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80336     return 0;
80337   }
80338   {
80339     try {
80340       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80341     } catch (std::out_of_range& e) {
80342       {
80343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80344       };
80345     } catch (std::exception& e) {
80346       {
80347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80348       };
80349     } catch (Dali::DaliException e) {
80350       {
80351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80352       };
80353     } catch (...) {
80354       {
80355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80356       };
80357     }
80358   }
80359
80360   jresult = (void *)result;
80361   return jresult;
80362 }
80363
80364
80365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80366   void * jresult ;
80367   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80368   Dali::Toolkit::ScrollView *arg2 = 0 ;
80369   Dali::Toolkit::ScrollView *result = 0 ;
80370
80371   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80372   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80373   if (!arg2) {
80374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80375     return 0;
80376   }
80377   {
80378     try {
80379       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80380     } catch (std::out_of_range& e) {
80381       {
80382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80383       };
80384     } catch (std::exception& e) {
80385       {
80386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80387       };
80388     } catch (Dali::DaliException e) {
80389       {
80390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80391       };
80392     } catch (...) {
80393       {
80394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80395       };
80396     }
80397   }
80398
80399   jresult = (void *)result;
80400   return jresult;
80401 }
80402
80403
80404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80405   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80406
80407   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80408   {
80409     try {
80410       delete arg1;
80411     } catch (std::out_of_range& e) {
80412       {
80413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80414       };
80415     } catch (std::exception& e) {
80416       {
80417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80418       };
80419     } catch (Dali::DaliException e) {
80420       {
80421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80422       };
80423     } catch (...) {
80424       {
80425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80426       };
80427     }
80428   }
80429
80430 }
80431
80432
80433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80434   void * jresult ;
80435   Dali::Toolkit::ScrollView result;
80436
80437   {
80438     try {
80439       result = Dali::Toolkit::ScrollView::New();
80440     } catch (std::out_of_range& e) {
80441       {
80442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80443       };
80444     } catch (std::exception& e) {
80445       {
80446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80447       };
80448     } catch (Dali::DaliException e) {
80449       {
80450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80451       };
80452     } catch (...) {
80453       {
80454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80455       };
80456     }
80457   }
80458
80459   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80460   return jresult;
80461 }
80462
80463
80464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80465   void * jresult ;
80466   Dali::BaseHandle arg1 ;
80467   Dali::BaseHandle *argp1 ;
80468   Dali::Toolkit::ScrollView result;
80469
80470   argp1 = (Dali::BaseHandle *)jarg1;
80471   if (!argp1) {
80472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80473     return 0;
80474   }
80475   arg1 = *argp1;
80476   {
80477     try {
80478       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80479     } catch (std::out_of_range& e) {
80480       {
80481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80482       };
80483     } catch (std::exception& e) {
80484       {
80485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80486       };
80487     } catch (Dali::DaliException e) {
80488       {
80489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80490       };
80491     } catch (...) {
80492       {
80493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80494       };
80495     }
80496   }
80497
80498   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80499   return jresult;
80500 }
80501
80502
80503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80504   void * jresult ;
80505   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80506   Dali::AlphaFunction result;
80507
80508   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80509   {
80510     try {
80511       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80512     } catch (std::out_of_range& e) {
80513       {
80514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80515       };
80516     } catch (std::exception& e) {
80517       {
80518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80519       };
80520     } catch (Dali::DaliException e) {
80521       {
80522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80523       };
80524     } catch (...) {
80525       {
80526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80527       };
80528     }
80529   }
80530
80531   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80532   return jresult;
80533 }
80534
80535
80536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80537   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80538   Dali::AlphaFunction arg2 ;
80539   Dali::AlphaFunction *argp2 ;
80540
80541   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80542   argp2 = (Dali::AlphaFunction *)jarg2;
80543   if (!argp2) {
80544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80545     return ;
80546   }
80547   arg2 = *argp2;
80548   {
80549     try {
80550       (arg1)->SetScrollSnapAlphaFunction(arg2);
80551     } catch (std::out_of_range& e) {
80552       {
80553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80554       };
80555     } catch (std::exception& e) {
80556       {
80557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80558       };
80559     } catch (Dali::DaliException e) {
80560       {
80561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80562       };
80563     } catch (...) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80566       };
80567     }
80568   }
80569
80570 }
80571
80572
80573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80574   void * jresult ;
80575   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80576   Dali::AlphaFunction result;
80577
80578   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80579   {
80580     try {
80581       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80582     } catch (std::out_of_range& e) {
80583       {
80584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80585       };
80586     } catch (std::exception& e) {
80587       {
80588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80589       };
80590     } catch (Dali::DaliException e) {
80591       {
80592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80593       };
80594     } catch (...) {
80595       {
80596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80597       };
80598     }
80599   }
80600
80601   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80602   return jresult;
80603 }
80604
80605
80606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80608   Dali::AlphaFunction arg2 ;
80609   Dali::AlphaFunction *argp2 ;
80610
80611   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80612   argp2 = (Dali::AlphaFunction *)jarg2;
80613   if (!argp2) {
80614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80615     return ;
80616   }
80617   arg2 = *argp2;
80618   {
80619     try {
80620       (arg1)->SetScrollFlickAlphaFunction(arg2);
80621     } catch (std::out_of_range& e) {
80622       {
80623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80624       };
80625     } catch (std::exception& e) {
80626       {
80627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80628       };
80629     } catch (Dali::DaliException e) {
80630       {
80631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80632       };
80633     } catch (...) {
80634       {
80635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80636       };
80637     }
80638   }
80639
80640 }
80641
80642
80643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80644   float jresult ;
80645   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80646   float result;
80647
80648   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80649   {
80650     try {
80651       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80652     } catch (std::out_of_range& e) {
80653       {
80654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80655       };
80656     } catch (std::exception& e) {
80657       {
80658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80659       };
80660     } catch (Dali::DaliException e) {
80661       {
80662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80663       };
80664     } catch (...) {
80665       {
80666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80667       };
80668     }
80669   }
80670
80671   jresult = result;
80672   return jresult;
80673 }
80674
80675
80676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80677   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80678   float arg2 ;
80679
80680   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80681   arg2 = (float)jarg2;
80682   {
80683     try {
80684       (arg1)->SetScrollSnapDuration(arg2);
80685     } catch (std::out_of_range& e) {
80686       {
80687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80688       };
80689     } catch (std::exception& e) {
80690       {
80691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80692       };
80693     } catch (Dali::DaliException e) {
80694       {
80695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80696       };
80697     } catch (...) {
80698       {
80699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80700       };
80701     }
80702   }
80703
80704 }
80705
80706
80707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80708   float jresult ;
80709   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80710   float result;
80711
80712   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80713   {
80714     try {
80715       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80716     } catch (std::out_of_range& e) {
80717       {
80718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80719       };
80720     } catch (std::exception& e) {
80721       {
80722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80723       };
80724     } catch (Dali::DaliException e) {
80725       {
80726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80727       };
80728     } catch (...) {
80729       {
80730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80731       };
80732     }
80733   }
80734
80735   jresult = result;
80736   return jresult;
80737 }
80738
80739
80740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80741   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80742   float arg2 ;
80743
80744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80745   arg2 = (float)jarg2;
80746   {
80747     try {
80748       (arg1)->SetScrollFlickDuration(arg2);
80749     } catch (std::out_of_range& e) {
80750       {
80751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80752       };
80753     } catch (std::exception& e) {
80754       {
80755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80756       };
80757     } catch (Dali::DaliException e) {
80758       {
80759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80760       };
80761     } catch (...) {
80762       {
80763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80764       };
80765     }
80766   }
80767
80768 }
80769
80770
80771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80772   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80773   Dali::Toolkit::RulerPtr arg2 ;
80774   Dali::Toolkit::RulerPtr *argp2 ;
80775
80776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80777   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80778   if (!argp2) {
80779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80780     return ;
80781   }
80782   arg2 = *argp2;
80783   {
80784     try {
80785       (arg1)->SetRulerX(arg2);
80786     } catch (std::out_of_range& e) {
80787       {
80788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80789       };
80790     } catch (std::exception& e) {
80791       {
80792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80793       };
80794     } catch (Dali::DaliException e) {
80795       {
80796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80797       };
80798     } catch (...) {
80799       {
80800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80801       };
80802     }
80803   }
80804
80805 }
80806
80807
80808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80809   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80810   Dali::Toolkit::RulerPtr arg2 ;
80811   Dali::Toolkit::RulerPtr *argp2 ;
80812
80813   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80814   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80815   if (!argp2) {
80816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80817     return ;
80818   }
80819   arg2 = *argp2;
80820   {
80821     try {
80822       (arg1)->SetRulerY(arg2);
80823     } catch (std::out_of_range& e) {
80824       {
80825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80826       };
80827     } catch (std::exception& e) {
80828       {
80829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80830       };
80831     } catch (Dali::DaliException e) {
80832       {
80833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80834       };
80835     } catch (...) {
80836       {
80837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80838       };
80839     }
80840   }
80841
80842 }
80843
80844
80845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80846   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80847   bool arg2 ;
80848
80849   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80850   arg2 = jarg2 ? true : false;
80851   {
80852     try {
80853       (arg1)->SetScrollSensitive(arg2);
80854     } catch (std::out_of_range& e) {
80855       {
80856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80857       };
80858     } catch (std::exception& e) {
80859       {
80860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80861       };
80862     } catch (Dali::DaliException e) {
80863       {
80864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80865       };
80866     } catch (...) {
80867       {
80868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80869       };
80870     }
80871   }
80872
80873 }
80874
80875
80876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80877   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80878   float arg2 ;
80879   float arg3 ;
80880
80881   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80882   arg2 = (float)jarg2;
80883   arg3 = (float)jarg3;
80884   {
80885     try {
80886       (arg1)->SetMaxOvershoot(arg2,arg3);
80887     } catch (std::out_of_range& e) {
80888       {
80889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80890       };
80891     } catch (std::exception& e) {
80892       {
80893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80894       };
80895     } catch (Dali::DaliException e) {
80896       {
80897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80898       };
80899     } catch (...) {
80900       {
80901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80902       };
80903     }
80904   }
80905
80906 }
80907
80908
80909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80911   Dali::AlphaFunction arg2 ;
80912   Dali::AlphaFunction *argp2 ;
80913
80914   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80915   argp2 = (Dali::AlphaFunction *)jarg2;
80916   if (!argp2) {
80917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80918     return ;
80919   }
80920   arg2 = *argp2;
80921   {
80922     try {
80923       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80924     } catch (std::out_of_range& e) {
80925       {
80926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80927       };
80928     } catch (std::exception& e) {
80929       {
80930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80931       };
80932     } catch (Dali::DaliException e) {
80933       {
80934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80935       };
80936     } catch (...) {
80937       {
80938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80939       };
80940     }
80941   }
80942
80943 }
80944
80945
80946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80947   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80948   float arg2 ;
80949
80950   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80951   arg2 = (float)jarg2;
80952   {
80953     try {
80954       (arg1)->SetSnapOvershootDuration(arg2);
80955     } catch (std::out_of_range& e) {
80956       {
80957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80958       };
80959     } catch (std::exception& e) {
80960       {
80961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80962       };
80963     } catch (Dali::DaliException e) {
80964       {
80965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80966       };
80967     } catch (...) {
80968       {
80969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80970       };
80971     }
80972   }
80973
80974 }
80975
80976
80977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80978   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80979   bool arg2 ;
80980
80981   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80982   arg2 = jarg2 ? true : false;
80983   {
80984     try {
80985       (arg1)->SetActorAutoSnap(arg2);
80986     } catch (std::out_of_range& e) {
80987       {
80988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80989       };
80990     } catch (std::exception& e) {
80991       {
80992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80993       };
80994     } catch (Dali::DaliException e) {
80995       {
80996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80997       };
80998     } catch (...) {
80999       {
81000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81001       };
81002     }
81003   }
81004
81005 }
81006
81007
81008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
81009   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81010   bool arg2 ;
81011
81012   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81013   arg2 = jarg2 ? true : false;
81014   {
81015     try {
81016       (arg1)->SetWrapMode(arg2);
81017     } catch (std::out_of_range& e) {
81018       {
81019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81020       };
81021     } catch (std::exception& e) {
81022       {
81023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81024       };
81025     } catch (Dali::DaliException e) {
81026       {
81027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81028       };
81029     } catch (...) {
81030       {
81031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81032       };
81033     }
81034   }
81035
81036 }
81037
81038
81039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
81040   int jresult ;
81041   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81042   int result;
81043
81044   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81045   {
81046     try {
81047       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
81048     } catch (std::out_of_range& e) {
81049       {
81050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81051       };
81052     } catch (std::exception& e) {
81053       {
81054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81055       };
81056     } catch (Dali::DaliException e) {
81057       {
81058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81059       };
81060     } catch (...) {
81061       {
81062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81063       };
81064     }
81065   }
81066
81067   jresult = result;
81068   return jresult;
81069 }
81070
81071
81072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81073   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81074   int arg2 ;
81075
81076   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81077   arg2 = (int)jarg2;
81078   {
81079     try {
81080       (arg1)->SetScrollUpdateDistance(arg2);
81081     } catch (std::out_of_range& e) {
81082       {
81083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81084       };
81085     } catch (std::exception& e) {
81086       {
81087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81088       };
81089     } catch (Dali::DaliException e) {
81090       {
81091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81092       };
81093     } catch (...) {
81094       {
81095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81096       };
81097     }
81098   }
81099
81100 }
81101
81102
81103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81104   unsigned int jresult ;
81105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81106   bool result;
81107
81108   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81109   {
81110     try {
81111       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
81112     } catch (std::out_of_range& e) {
81113       {
81114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81115       };
81116     } catch (std::exception& e) {
81117       {
81118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81119       };
81120     } catch (Dali::DaliException e) {
81121       {
81122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81123       };
81124     } catch (...) {
81125       {
81126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81127       };
81128     }
81129   }
81130
81131   jresult = result;
81132   return jresult;
81133 }
81134
81135
81136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81137   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81138   bool arg2 ;
81139
81140   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81141   arg2 = jarg2 ? true : false;
81142   {
81143     try {
81144       (arg1)->SetAxisAutoLock(arg2);
81145     } catch (std::out_of_range& e) {
81146       {
81147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81148       };
81149     } catch (std::exception& e) {
81150       {
81151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81152       };
81153     } catch (Dali::DaliException e) {
81154       {
81155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81156       };
81157     } catch (...) {
81158       {
81159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81160       };
81161     }
81162   }
81163
81164 }
81165
81166
81167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
81168   float jresult ;
81169   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81170   float result;
81171
81172   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81173   {
81174     try {
81175       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
81176     } catch (std::out_of_range& e) {
81177       {
81178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81179       };
81180     } catch (std::exception& e) {
81181       {
81182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81183       };
81184     } catch (Dali::DaliException e) {
81185       {
81186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81187       };
81188     } catch (...) {
81189       {
81190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81191       };
81192     }
81193   }
81194
81195   jresult = result;
81196   return jresult;
81197 }
81198
81199
81200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
81201   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81202   float arg2 ;
81203
81204   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81205   arg2 = (float)jarg2;
81206   {
81207     try {
81208       (arg1)->SetAxisAutoLockGradient(arg2);
81209     } catch (std::out_of_range& e) {
81210       {
81211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81212       };
81213     } catch (std::exception& e) {
81214       {
81215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81216       };
81217     } catch (Dali::DaliException e) {
81218       {
81219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81220       };
81221     } catch (...) {
81222       {
81223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81224       };
81225     }
81226   }
81227
81228 }
81229
81230
81231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81232   float jresult ;
81233   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81234   float result;
81235
81236   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81237   {
81238     try {
81239       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81240     } catch (std::out_of_range& e) {
81241       {
81242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81243       };
81244     } catch (std::exception& e) {
81245       {
81246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81247       };
81248     } catch (Dali::DaliException e) {
81249       {
81250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81251       };
81252     } catch (...) {
81253       {
81254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81255       };
81256     }
81257   }
81258
81259   jresult = result;
81260   return jresult;
81261 }
81262
81263
81264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81265   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81266   float arg2 ;
81267
81268   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81269   arg2 = (float)jarg2;
81270   {
81271     try {
81272       (arg1)->SetFrictionCoefficient(arg2);
81273     } catch (std::out_of_range& e) {
81274       {
81275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81276       };
81277     } catch (std::exception& e) {
81278       {
81279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81280       };
81281     } catch (Dali::DaliException e) {
81282       {
81283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81284       };
81285     } catch (...) {
81286       {
81287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81288       };
81289     }
81290   }
81291
81292 }
81293
81294
81295 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81296   float jresult ;
81297   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81298   float result;
81299
81300   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81301   {
81302     try {
81303       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81304     } catch (std::out_of_range& e) {
81305       {
81306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81307       };
81308     } catch (std::exception& e) {
81309       {
81310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81311       };
81312     } catch (Dali::DaliException e) {
81313       {
81314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81315       };
81316     } catch (...) {
81317       {
81318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81319       };
81320     }
81321   }
81322
81323   jresult = result;
81324   return jresult;
81325 }
81326
81327
81328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81329   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81330   float arg2 ;
81331
81332   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81333   arg2 = (float)jarg2;
81334   {
81335     try {
81336       (arg1)->SetFlickSpeedCoefficient(arg2);
81337     } catch (std::out_of_range& e) {
81338       {
81339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81340       };
81341     } catch (std::exception& e) {
81342       {
81343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81344       };
81345     } catch (Dali::DaliException e) {
81346       {
81347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81348       };
81349     } catch (...) {
81350       {
81351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81352       };
81353     }
81354   }
81355
81356 }
81357
81358
81359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81360   void * jresult ;
81361   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81362   Dali::Vector2 result;
81363
81364   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81365   {
81366     try {
81367       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81368     } catch (std::out_of_range& e) {
81369       {
81370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81371       };
81372     } catch (std::exception& e) {
81373       {
81374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81375       };
81376     } catch (Dali::DaliException e) {
81377       {
81378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81379       };
81380     } catch (...) {
81381       {
81382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81383       };
81384     }
81385   }
81386
81387   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81388   return jresult;
81389 }
81390
81391
81392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81393   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81394   Dali::Vector2 *arg2 = 0 ;
81395
81396   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81397   arg2 = (Dali::Vector2 *)jarg2;
81398   if (!arg2) {
81399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81400     return ;
81401   }
81402   {
81403     try {
81404       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81405     } catch (std::out_of_range& e) {
81406       {
81407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81408       };
81409     } catch (std::exception& e) {
81410       {
81411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81412       };
81413     } catch (Dali::DaliException e) {
81414       {
81415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81416       };
81417     } catch (...) {
81418       {
81419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81420       };
81421     }
81422   }
81423
81424 }
81425
81426
81427 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81428   float jresult ;
81429   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81430   float result;
81431
81432   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81433   {
81434     try {
81435       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81436     } catch (std::out_of_range& e) {
81437       {
81438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81439       };
81440     } catch (std::exception& e) {
81441       {
81442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81443       };
81444     } catch (Dali::DaliException e) {
81445       {
81446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81447       };
81448     } catch (...) {
81449       {
81450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81451       };
81452     }
81453   }
81454
81455   jresult = result;
81456   return jresult;
81457 }
81458
81459
81460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81461   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81462   float arg2 ;
81463
81464   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81465   arg2 = (float)jarg2;
81466   {
81467     try {
81468       (arg1)->SetMinimumSpeedForFlick(arg2);
81469     } catch (std::out_of_range& e) {
81470       {
81471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81472       };
81473     } catch (std::exception& e) {
81474       {
81475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81476       };
81477     } catch (Dali::DaliException e) {
81478       {
81479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81480       };
81481     } catch (...) {
81482       {
81483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81484       };
81485     }
81486   }
81487
81488 }
81489
81490
81491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81492   float jresult ;
81493   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81494   float result;
81495
81496   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81497   {
81498     try {
81499       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81500     } catch (std::out_of_range& e) {
81501       {
81502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81503       };
81504     } catch (std::exception& e) {
81505       {
81506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81507       };
81508     } catch (Dali::DaliException e) {
81509       {
81510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81511       };
81512     } catch (...) {
81513       {
81514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81515       };
81516     }
81517   }
81518
81519   jresult = result;
81520   return jresult;
81521 }
81522
81523
81524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81525   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81526   float arg2 ;
81527
81528   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81529   arg2 = (float)jarg2;
81530   {
81531     try {
81532       (arg1)->SetMaxFlickSpeed(arg2);
81533     } catch (std::out_of_range& e) {
81534       {
81535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81536       };
81537     } catch (std::exception& e) {
81538       {
81539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81540       };
81541     } catch (Dali::DaliException e) {
81542       {
81543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81544       };
81545     } catch (...) {
81546       {
81547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81548       };
81549     }
81550   }
81551
81552 }
81553
81554
81555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81556   void * jresult ;
81557   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81558   Dali::Vector2 result;
81559
81560   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81561   {
81562     try {
81563       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81564     } catch (std::out_of_range& e) {
81565       {
81566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81567       };
81568     } catch (std::exception& e) {
81569       {
81570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81571       };
81572     } catch (Dali::DaliException e) {
81573       {
81574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81575       };
81576     } catch (...) {
81577       {
81578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81579       };
81580     }
81581   }
81582
81583   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81584   return jresult;
81585 }
81586
81587
81588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81589   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81590   Dali::Vector2 arg2 ;
81591   Dali::Vector2 *argp2 ;
81592
81593   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81594   argp2 = (Dali::Vector2 *)jarg2;
81595   if (!argp2) {
81596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81597     return ;
81598   }
81599   arg2 = *argp2;
81600   {
81601     try {
81602       (arg1)->SetWheelScrollDistanceStep(arg2);
81603     } catch (std::out_of_range& e) {
81604       {
81605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81606       };
81607     } catch (std::exception& e) {
81608       {
81609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81610       };
81611     } catch (Dali::DaliException e) {
81612       {
81613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81614       };
81615     } catch (...) {
81616       {
81617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81618       };
81619     }
81620   }
81621
81622 }
81623
81624
81625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81626   void * jresult ;
81627   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81628   Dali::Vector2 result;
81629
81630   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81631   {
81632     try {
81633       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81634     } catch (std::out_of_range& e) {
81635       {
81636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81637       };
81638     } catch (std::exception& e) {
81639       {
81640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81641       };
81642     } catch (Dali::DaliException e) {
81643       {
81644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81645       };
81646     } catch (...) {
81647       {
81648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81649       };
81650     }
81651   }
81652
81653   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81654   return jresult;
81655 }
81656
81657
81658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81659   unsigned int jresult ;
81660   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81661   unsigned int result;
81662
81663   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81664   {
81665     try {
81666       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81667     } catch (std::out_of_range& e) {
81668       {
81669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81670       };
81671     } catch (std::exception& e) {
81672       {
81673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81674       };
81675     } catch (Dali::DaliException e) {
81676       {
81677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81678       };
81679     } catch (...) {
81680       {
81681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81682       };
81683     }
81684   }
81685
81686   jresult = result;
81687   return jresult;
81688 }
81689
81690
81691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81692   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81693   Dali::Vector2 *arg2 = 0 ;
81694
81695   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81696   arg2 = (Dali::Vector2 *)jarg2;
81697   if (!arg2) {
81698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81699     return ;
81700   }
81701   {
81702     try {
81703       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81704     } catch (std::out_of_range& e) {
81705       {
81706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81707       };
81708     } catch (std::exception& e) {
81709       {
81710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81711       };
81712     } catch (Dali::DaliException e) {
81713       {
81714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81715       };
81716     } catch (...) {
81717       {
81718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81719       };
81720     }
81721   }
81722
81723 }
81724
81725
81726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81727   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81728   Dali::Vector2 *arg2 = 0 ;
81729   float arg3 ;
81730
81731   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81732   arg2 = (Dali::Vector2 *)jarg2;
81733   if (!arg2) {
81734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81735     return ;
81736   }
81737   arg3 = (float)jarg3;
81738   {
81739     try {
81740       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81741     } catch (std::out_of_range& e) {
81742       {
81743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81744       };
81745     } catch (std::exception& e) {
81746       {
81747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81748       };
81749     } catch (Dali::DaliException e) {
81750       {
81751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81752       };
81753     } catch (...) {
81754       {
81755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81756       };
81757     }
81758   }
81759
81760 }
81761
81762
81763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81764   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81765   Dali::Vector2 *arg2 = 0 ;
81766   float arg3 ;
81767   Dali::AlphaFunction arg4 ;
81768   Dali::AlphaFunction *argp4 ;
81769
81770   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81771   arg2 = (Dali::Vector2 *)jarg2;
81772   if (!arg2) {
81773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81774     return ;
81775   }
81776   arg3 = (float)jarg3;
81777   argp4 = (Dali::AlphaFunction *)jarg4;
81778   if (!argp4) {
81779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81780     return ;
81781   }
81782   arg4 = *argp4;
81783   {
81784     try {
81785       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81786     } catch (std::out_of_range& e) {
81787       {
81788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81789       };
81790     } catch (std::exception& e) {
81791       {
81792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81793       };
81794     } catch (Dali::DaliException e) {
81795       {
81796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81797       };
81798     } catch (...) {
81799       {
81800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81801       };
81802     }
81803   }
81804
81805 }
81806
81807
81808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81809   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81810   Dali::Vector2 *arg2 = 0 ;
81811   float arg3 ;
81812   Dali::Toolkit::DirectionBias arg4 ;
81813   Dali::Toolkit::DirectionBias arg5 ;
81814
81815   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81816   arg2 = (Dali::Vector2 *)jarg2;
81817   if (!arg2) {
81818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81819     return ;
81820   }
81821   arg3 = (float)jarg3;
81822   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81823   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81824   {
81825     try {
81826       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81827     } catch (std::out_of_range& e) {
81828       {
81829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81830       };
81831     } catch (std::exception& e) {
81832       {
81833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81834       };
81835     } catch (Dali::DaliException e) {
81836       {
81837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81838       };
81839     } catch (...) {
81840       {
81841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81842       };
81843     }
81844   }
81845
81846 }
81847
81848
81849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81850   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81851   Dali::Vector2 *arg2 = 0 ;
81852   float arg3 ;
81853   Dali::AlphaFunction arg4 ;
81854   Dali::Toolkit::DirectionBias arg5 ;
81855   Dali::Toolkit::DirectionBias arg6 ;
81856   Dali::AlphaFunction *argp4 ;
81857
81858   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81859   arg2 = (Dali::Vector2 *)jarg2;
81860   if (!arg2) {
81861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81862     return ;
81863   }
81864   arg3 = (float)jarg3;
81865   argp4 = (Dali::AlphaFunction *)jarg4;
81866   if (!argp4) {
81867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81868     return ;
81869   }
81870   arg4 = *argp4;
81871   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81872   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81873   {
81874     try {
81875       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81876     } catch (std::out_of_range& e) {
81877       {
81878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81879       };
81880     } catch (std::exception& e) {
81881       {
81882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81883       };
81884     } catch (Dali::DaliException e) {
81885       {
81886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81887       };
81888     } catch (...) {
81889       {
81890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81891       };
81892     }
81893   }
81894
81895 }
81896
81897
81898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81899   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81900   unsigned int arg2 ;
81901
81902   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81903   arg2 = (unsigned int)jarg2;
81904   {
81905     try {
81906       (arg1)->ScrollTo(arg2);
81907     } catch (std::out_of_range& e) {
81908       {
81909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81910       };
81911     } catch (std::exception& e) {
81912       {
81913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81914       };
81915     } catch (Dali::DaliException e) {
81916       {
81917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81918       };
81919     } catch (...) {
81920       {
81921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81922       };
81923     }
81924   }
81925
81926 }
81927
81928
81929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81930   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81931   unsigned int arg2 ;
81932   float arg3 ;
81933
81934   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81935   arg2 = (unsigned int)jarg2;
81936   arg3 = (float)jarg3;
81937   {
81938     try {
81939       (arg1)->ScrollTo(arg2,arg3);
81940     } catch (std::out_of_range& e) {
81941       {
81942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81943       };
81944     } catch (std::exception& e) {
81945       {
81946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81947       };
81948     } catch (Dali::DaliException e) {
81949       {
81950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81951       };
81952     } catch (...) {
81953       {
81954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81955       };
81956     }
81957   }
81958
81959 }
81960
81961
81962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81963   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81964   unsigned int arg2 ;
81965   float arg3 ;
81966   Dali::Toolkit::DirectionBias arg4 ;
81967
81968   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81969   arg2 = (unsigned int)jarg2;
81970   arg3 = (float)jarg3;
81971   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81972   {
81973     try {
81974       (arg1)->ScrollTo(arg2,arg3,arg4);
81975     } catch (std::out_of_range& e) {
81976       {
81977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81978       };
81979     } catch (std::exception& e) {
81980       {
81981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81982       };
81983     } catch (Dali::DaliException e) {
81984       {
81985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81986       };
81987     } catch (...) {
81988       {
81989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81990       };
81991     }
81992   }
81993
81994 }
81995
81996
81997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81998   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81999   Dali::Actor *arg2 = 0 ;
82000
82001   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82002   arg2 = (Dali::Actor *)jarg2;
82003   if (!arg2) {
82004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82005     return ;
82006   }
82007   {
82008     try {
82009       (arg1)->ScrollTo(*arg2);
82010     } catch (std::out_of_range& e) {
82011       {
82012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82013       };
82014     } catch (std::exception& e) {
82015       {
82016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82017       };
82018     } catch (Dali::DaliException e) {
82019       {
82020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82021       };
82022     } catch (...) {
82023       {
82024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82025       };
82026     }
82027   }
82028
82029 }
82030
82031
82032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
82033   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82034   Dali::Actor *arg2 = 0 ;
82035   float arg3 ;
82036
82037   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82038   arg2 = (Dali::Actor *)jarg2;
82039   if (!arg2) {
82040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82041     return ;
82042   }
82043   arg3 = (float)jarg3;
82044   {
82045     try {
82046       (arg1)->ScrollTo(*arg2,arg3);
82047     } catch (std::out_of_range& e) {
82048       {
82049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82050       };
82051     } catch (std::exception& e) {
82052       {
82053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82054       };
82055     } catch (Dali::DaliException e) {
82056       {
82057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82058       };
82059     } catch (...) {
82060       {
82061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82062       };
82063     }
82064   }
82065
82066 }
82067
82068
82069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82070   unsigned int jresult ;
82071   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82072   bool result;
82073
82074   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82075   {
82076     try {
82077       result = (bool)(arg1)->ScrollToSnapPoint();
82078     } catch (std::out_of_range& e) {
82079       {
82080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82081       };
82082     } catch (std::exception& e) {
82083       {
82084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82085       };
82086     } catch (Dali::DaliException e) {
82087       {
82088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82089       };
82090     } catch (...) {
82091       {
82092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82093       };
82094     }
82095   }
82096
82097   jresult = result;
82098   return jresult;
82099 }
82100
82101
82102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82103   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82104   Dali::Constraint arg2 ;
82105   Dali::Constraint *argp2 ;
82106
82107   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82108   argp2 = (Dali::Constraint *)jarg2;
82109   if (!argp2) {
82110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82111     return ;
82112   }
82113   arg2 = *argp2;
82114   {
82115     try {
82116       (arg1)->ApplyConstraintToChildren(arg2);
82117     } catch (std::out_of_range& e) {
82118       {
82119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82120       };
82121     } catch (std::exception& e) {
82122       {
82123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82124       };
82125     } catch (Dali::DaliException e) {
82126       {
82127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82128       };
82129     } catch (...) {
82130       {
82131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82132       };
82133     }
82134   }
82135
82136 }
82137
82138
82139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82140   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82141
82142   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82143   {
82144     try {
82145       (arg1)->RemoveConstraintsFromChildren();
82146     } catch (std::out_of_range& e) {
82147       {
82148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82149       };
82150     } catch (std::exception& e) {
82151       {
82152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82153       };
82154     } catch (Dali::DaliException e) {
82155       {
82156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82157       };
82158     } catch (...) {
82159       {
82160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82161       };
82162     }
82163   }
82164
82165 }
82166
82167
82168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82169   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82170   Dali::Toolkit::ScrollViewEffect arg2 ;
82171   Dali::Toolkit::ScrollViewEffect *argp2 ;
82172
82173   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82174   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82175   if (!argp2) {
82176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82177     return ;
82178   }
82179   arg2 = *argp2;
82180   {
82181     try {
82182       (arg1)->ApplyEffect(arg2);
82183     } catch (std::out_of_range& e) {
82184       {
82185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82186       };
82187     } catch (std::exception& e) {
82188       {
82189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82190       };
82191     } catch (Dali::DaliException e) {
82192       {
82193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82194       };
82195     } catch (...) {
82196       {
82197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82198       };
82199     }
82200   }
82201
82202 }
82203
82204
82205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
82206   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82207   Dali::Toolkit::ScrollViewEffect arg2 ;
82208   Dali::Toolkit::ScrollViewEffect *argp2 ;
82209
82210   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82211   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82212   if (!argp2) {
82213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82214     return ;
82215   }
82216   arg2 = *argp2;
82217   {
82218     try {
82219       (arg1)->RemoveEffect(arg2);
82220     } catch (std::out_of_range& e) {
82221       {
82222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82223       };
82224     } catch (std::exception& e) {
82225       {
82226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82227       };
82228     } catch (Dali::DaliException e) {
82229       {
82230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82231       };
82232     } catch (...) {
82233       {
82234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82235       };
82236     }
82237   }
82238
82239 }
82240
82241
82242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82243   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82244
82245   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82246   {
82247     try {
82248       (arg1)->RemoveAllEffects();
82249     } catch (std::out_of_range& e) {
82250       {
82251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82252       };
82253     } catch (std::exception& e) {
82254       {
82255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82256       };
82257     } catch (Dali::DaliException e) {
82258       {
82259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82260       };
82261     } catch (...) {
82262       {
82263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82264       };
82265     }
82266   }
82267
82268 }
82269
82270
82271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82272   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82273   Dali::Actor arg2 ;
82274   Dali::Actor *argp2 ;
82275
82276   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82277   argp2 = (Dali::Actor *)jarg2;
82278   if (!argp2) {
82279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82280     return ;
82281   }
82282   arg2 = *argp2;
82283   {
82284     try {
82285       (arg1)->BindActor(arg2);
82286     } catch (std::out_of_range& e) {
82287       {
82288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82289       };
82290     } catch (std::exception& e) {
82291       {
82292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82293       };
82294     } catch (Dali::DaliException e) {
82295       {
82296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82297       };
82298     } catch (...) {
82299       {
82300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82301       };
82302     }
82303   }
82304
82305 }
82306
82307
82308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82309   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82310   Dali::Actor arg2 ;
82311   Dali::Actor *argp2 ;
82312
82313   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82314   argp2 = (Dali::Actor *)jarg2;
82315   if (!argp2) {
82316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82317     return ;
82318   }
82319   arg2 = *argp2;
82320   {
82321     try {
82322       (arg1)->UnbindActor(arg2);
82323     } catch (std::out_of_range& e) {
82324       {
82325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82326       };
82327     } catch (std::exception& e) {
82328       {
82329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82330       };
82331     } catch (Dali::DaliException e) {
82332       {
82333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82334       };
82335     } catch (...) {
82336       {
82337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82338       };
82339     }
82340   }
82341
82342 }
82343
82344
82345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82346   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82347   Dali::Radian arg2 ;
82348   Dali::Radian arg3 ;
82349   Dali::Radian *argp2 ;
82350   Dali::Radian *argp3 ;
82351
82352   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82353   argp2 = (Dali::Radian *)jarg2;
82354   if (!argp2) {
82355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82356     return ;
82357   }
82358   arg2 = *argp2;
82359   argp3 = (Dali::Radian *)jarg3;
82360   if (!argp3) {
82361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82362     return ;
82363   }
82364   arg3 = *argp3;
82365   {
82366     try {
82367       (arg1)->SetScrollingDirection(arg2,arg3);
82368     } catch (std::out_of_range& e) {
82369       {
82370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82371       };
82372     } catch (std::exception& e) {
82373       {
82374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82375       };
82376     } catch (Dali::DaliException e) {
82377       {
82378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82379       };
82380     } catch (...) {
82381       {
82382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82383       };
82384     }
82385   }
82386
82387 }
82388
82389
82390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82391   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82392   Dali::Radian arg2 ;
82393   Dali::Radian *argp2 ;
82394
82395   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82396   argp2 = (Dali::Radian *)jarg2;
82397   if (!argp2) {
82398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82399     return ;
82400   }
82401   arg2 = *argp2;
82402   {
82403     try {
82404       (arg1)->SetScrollingDirection(arg2);
82405     } catch (std::out_of_range& e) {
82406       {
82407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82408       };
82409     } catch (std::exception& e) {
82410       {
82411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82412       };
82413     } catch (Dali::DaliException e) {
82414       {
82415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82416       };
82417     } catch (...) {
82418       {
82419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82420       };
82421     }
82422   }
82423
82424 }
82425
82426
82427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82428   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82429   Dali::Radian arg2 ;
82430   Dali::Radian *argp2 ;
82431
82432   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82433   argp2 = (Dali::Radian *)jarg2;
82434   if (!argp2) {
82435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82436     return ;
82437   }
82438   arg2 = *argp2;
82439   {
82440     try {
82441       (arg1)->RemoveScrollingDirection(arg2);
82442     } catch (std::out_of_range& e) {
82443       {
82444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82445       };
82446     } catch (std::exception& e) {
82447       {
82448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82449       };
82450     } catch (Dali::DaliException e) {
82451       {
82452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82453       };
82454     } catch (...) {
82455       {
82456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82457       };
82458     }
82459   }
82460
82461 }
82462
82463
82464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82465   void * jresult ;
82466   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82467   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82468
82469   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82470   {
82471     try {
82472       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82473     } catch (std::out_of_range& e) {
82474       {
82475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82476       };
82477     } catch (std::exception& e) {
82478       {
82479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82480       };
82481     } catch (Dali::DaliException e) {
82482       {
82483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82484       };
82485     } catch (...) {
82486       {
82487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82488       };
82489     }
82490   }
82491
82492   jresult = (void *)result;
82493   return jresult;
82494 }
82495
82496
82497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82498   int jresult ;
82499   int result;
82500
82501   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82502   jresult = (int)result;
82503   return jresult;
82504 }
82505
82506
82507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82508   int jresult ;
82509   int result;
82510
82511   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82512   jresult = (int)result;
82513   return jresult;
82514 }
82515
82516
82517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82518   int jresult ;
82519   int result;
82520
82521   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82522   jresult = (int)result;
82523   return jresult;
82524 }
82525
82526
82527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82528   int jresult ;
82529   int result;
82530
82531   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82532   jresult = (int)result;
82533   return jresult;
82534 }
82535
82536
82537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82538   int jresult ;
82539   int result;
82540
82541   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82542   jresult = (int)result;
82543   return jresult;
82544 }
82545
82546
82547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82548   void * jresult ;
82549   Dali::Toolkit::TableView::Property *result = 0 ;
82550
82551   {
82552     try {
82553       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82554     } catch (std::out_of_range& e) {
82555       {
82556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82557       };
82558     } catch (std::exception& e) {
82559       {
82560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82561       };
82562     } catch (Dali::DaliException e) {
82563       {
82564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82565       };
82566     } catch (...) {
82567       {
82568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82569       };
82570     }
82571   }
82572
82573   jresult = (void *)result;
82574   return jresult;
82575 }
82576
82577
82578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82579   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82580
82581   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82582   {
82583     try {
82584       delete arg1;
82585     } catch (std::out_of_range& e) {
82586       {
82587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82588       };
82589     } catch (std::exception& e) {
82590       {
82591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82592       };
82593     } catch (Dali::DaliException e) {
82594       {
82595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82596       };
82597     } catch (...) {
82598       {
82599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82600       };
82601     }
82602   }
82603
82604 }
82605
82606
82607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82608   int jresult ;
82609   int result;
82610
82611   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82612   jresult = (int)result;
82613   return jresult;
82614 }
82615
82616
82617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82618   int jresult ;
82619   int result;
82620
82621   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82622   jresult = (int)result;
82623   return jresult;
82624 }
82625
82626
82627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82628   int jresult ;
82629   int result;
82630
82631   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82632   jresult = (int)result;
82633   return jresult;
82634 }
82635
82636
82637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82638   int jresult ;
82639   int result;
82640
82641   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82642   jresult = (int)result;
82643   return jresult;
82644 }
82645
82646
82647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82648   int jresult ;
82649   int result;
82650
82651   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82652   jresult = (int)result;
82653   return jresult;
82654 }
82655
82656
82657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82658   void * jresult ;
82659   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82660
82661   {
82662     try {
82663       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82664     } catch (std::out_of_range& e) {
82665       {
82666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82667       };
82668     } catch (std::exception& e) {
82669       {
82670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82671       };
82672     } catch (Dali::DaliException e) {
82673       {
82674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82675       };
82676     } catch (...) {
82677       {
82678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82679       };
82680     }
82681   }
82682
82683   jresult = (void *)result;
82684   return jresult;
82685 }
82686
82687
82688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82689   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82690
82691   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82692   {
82693     try {
82694       delete arg1;
82695     } catch (std::out_of_range& e) {
82696       {
82697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82698       };
82699     } catch (std::exception& e) {
82700       {
82701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82702       };
82703     } catch (Dali::DaliException e) {
82704       {
82705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82706       };
82707     } catch (...) {
82708       {
82709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82710       };
82711     }
82712   }
82713
82714 }
82715
82716
82717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82718   void * jresult ;
82719   unsigned int arg1 ;
82720   unsigned int arg2 ;
82721   unsigned int arg3 ;
82722   unsigned int arg4 ;
82723   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82724
82725   arg1 = (unsigned int)jarg1;
82726   arg2 = (unsigned int)jarg2;
82727   arg3 = (unsigned int)jarg3;
82728   arg4 = (unsigned int)jarg4;
82729   {
82730     try {
82731       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82732     } catch (std::out_of_range& e) {
82733       {
82734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82735       };
82736     } catch (std::exception& e) {
82737       {
82738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82739       };
82740     } catch (Dali::DaliException e) {
82741       {
82742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82743       };
82744     } catch (...) {
82745       {
82746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82747       };
82748     }
82749   }
82750
82751   jresult = (void *)result;
82752   return jresult;
82753 }
82754
82755
82756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82757   void * jresult ;
82758   unsigned int arg1 ;
82759   unsigned int arg2 ;
82760   unsigned int arg3 ;
82761   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82762
82763   arg1 = (unsigned int)jarg1;
82764   arg2 = (unsigned int)jarg2;
82765   arg3 = (unsigned int)jarg3;
82766   {
82767     try {
82768       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82769     } catch (std::out_of_range& e) {
82770       {
82771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82772       };
82773     } catch (std::exception& e) {
82774       {
82775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82776       };
82777     } catch (Dali::DaliException e) {
82778       {
82779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82780       };
82781     } catch (...) {
82782       {
82783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82784       };
82785     }
82786   }
82787
82788   jresult = (void *)result;
82789   return jresult;
82790 }
82791
82792
82793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82794   void * jresult ;
82795   unsigned int arg1 ;
82796   unsigned int arg2 ;
82797   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82798
82799   arg1 = (unsigned int)jarg1;
82800   arg2 = (unsigned int)jarg2;
82801   {
82802     try {
82803       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82804     } catch (std::out_of_range& e) {
82805       {
82806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82807       };
82808     } catch (std::exception& e) {
82809       {
82810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82811       };
82812     } catch (Dali::DaliException e) {
82813       {
82814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82815       };
82816     } catch (...) {
82817       {
82818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82819       };
82820     }
82821   }
82822
82823   jresult = (void *)result;
82824   return jresult;
82825 }
82826
82827
82828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82829   void * jresult ;
82830   unsigned int arg1 ;
82831   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82832
82833   arg1 = (unsigned int)jarg1;
82834   {
82835     try {
82836       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82837     } catch (std::out_of_range& e) {
82838       {
82839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82840       };
82841     } catch (std::exception& e) {
82842       {
82843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82844       };
82845     } catch (Dali::DaliException e) {
82846       {
82847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82848       };
82849     } catch (...) {
82850       {
82851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82852       };
82853     }
82854   }
82855
82856   jresult = (void *)result;
82857   return jresult;
82858 }
82859
82860
82861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82862   void * jresult ;
82863   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82864
82865   {
82866     try {
82867       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82868     } catch (std::out_of_range& e) {
82869       {
82870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82871       };
82872     } catch (std::exception& e) {
82873       {
82874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82875       };
82876     } catch (Dali::DaliException e) {
82877       {
82878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82879       };
82880     } catch (...) {
82881       {
82882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82883       };
82884     }
82885   }
82886
82887   jresult = (void *)result;
82888   return jresult;
82889 }
82890
82891
82892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82893   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82894   unsigned int arg2 ;
82895
82896   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82897   arg2 = (unsigned int)jarg2;
82898   if (arg1) (arg1)->rowIndex = arg2;
82899 }
82900
82901
82902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82903   unsigned int jresult ;
82904   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82905   unsigned int result;
82906
82907   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82908   result = (unsigned int) ((arg1)->rowIndex);
82909   jresult = result;
82910   return jresult;
82911 }
82912
82913
82914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82915   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82916   unsigned int arg2 ;
82917
82918   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82919   arg2 = (unsigned int)jarg2;
82920   if (arg1) (arg1)->columnIndex = arg2;
82921 }
82922
82923
82924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82925   unsigned int jresult ;
82926   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82927   unsigned int result;
82928
82929   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82930   result = (unsigned int) ((arg1)->columnIndex);
82931   jresult = result;
82932   return jresult;
82933 }
82934
82935
82936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82937   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82938   unsigned int arg2 ;
82939
82940   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82941   arg2 = (unsigned int)jarg2;
82942   if (arg1) (arg1)->rowSpan = arg2;
82943 }
82944
82945
82946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82947   unsigned int jresult ;
82948   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82949   unsigned int result;
82950
82951   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82952   result = (unsigned int) ((arg1)->rowSpan);
82953   jresult = result;
82954   return jresult;
82955 }
82956
82957
82958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82959   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82960   unsigned int arg2 ;
82961
82962   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82963   arg2 = (unsigned int)jarg2;
82964   if (arg1) (arg1)->columnSpan = arg2;
82965 }
82966
82967
82968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82969   unsigned int jresult ;
82970   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82971   unsigned int result;
82972
82973   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82974   result = (unsigned int) ((arg1)->columnSpan);
82975   jresult = result;
82976   return jresult;
82977 }
82978
82979
82980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82981   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82982
82983   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82984   {
82985     try {
82986       delete arg1;
82987     } catch (std::out_of_range& e) {
82988       {
82989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82990       };
82991     } catch (std::exception& e) {
82992       {
82993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82994       };
82995     } catch (Dali::DaliException e) {
82996       {
82997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82998       };
82999     } catch (...) {
83000       {
83001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83002       };
83003     }
83004   }
83005
83006 }
83007
83008
83009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
83010   void * jresult ;
83011   Dali::Toolkit::TableView *result = 0 ;
83012
83013   {
83014     try {
83015       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
83016     } catch (std::out_of_range& e) {
83017       {
83018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83019       };
83020     } catch (std::exception& e) {
83021       {
83022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83023       };
83024     } catch (Dali::DaliException e) {
83025       {
83026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83027       };
83028     } catch (...) {
83029       {
83030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83031       };
83032     }
83033   }
83034
83035   jresult = (void *)result;
83036   return jresult;
83037 }
83038
83039
83040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
83041   void * jresult ;
83042   Dali::Toolkit::TableView *arg1 = 0 ;
83043   Dali::Toolkit::TableView *result = 0 ;
83044
83045   arg1 = (Dali::Toolkit::TableView *)jarg1;
83046   if (!arg1) {
83047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83048     return 0;
83049   }
83050   {
83051     try {
83052       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
83053     } catch (std::out_of_range& e) {
83054       {
83055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83056       };
83057     } catch (std::exception& e) {
83058       {
83059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83060       };
83061     } catch (Dali::DaliException e) {
83062       {
83063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83064       };
83065     } catch (...) {
83066       {
83067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83068       };
83069     }
83070   }
83071
83072   jresult = (void *)result;
83073   return jresult;
83074 }
83075
83076
83077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
83078   void * jresult ;
83079   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83080   Dali::Toolkit::TableView *arg2 = 0 ;
83081   Dali::Toolkit::TableView *result = 0 ;
83082
83083   arg1 = (Dali::Toolkit::TableView *)jarg1;
83084   arg2 = (Dali::Toolkit::TableView *)jarg2;
83085   if (!arg2) {
83086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83087     return 0;
83088   }
83089   {
83090     try {
83091       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
83092     } catch (std::out_of_range& e) {
83093       {
83094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83095       };
83096     } catch (std::exception& e) {
83097       {
83098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83099       };
83100     } catch (Dali::DaliException e) {
83101       {
83102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83103       };
83104     } catch (...) {
83105       {
83106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83107       };
83108     }
83109   }
83110
83111   jresult = (void *)result;
83112   return jresult;
83113 }
83114
83115
83116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83117   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83118
83119   arg1 = (Dali::Toolkit::TableView *)jarg1;
83120   {
83121     try {
83122       delete arg1;
83123     } catch (std::out_of_range& e) {
83124       {
83125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83126       };
83127     } catch (std::exception& e) {
83128       {
83129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83130       };
83131     } catch (Dali::DaliException e) {
83132       {
83133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83134       };
83135     } catch (...) {
83136       {
83137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83138       };
83139     }
83140   }
83141
83142 }
83143
83144
83145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83146   void * jresult ;
83147   unsigned int arg1 ;
83148   unsigned int arg2 ;
83149   Dali::Toolkit::TableView result;
83150
83151   arg1 = (unsigned int)jarg1;
83152   arg2 = (unsigned int)jarg2;
83153   {
83154     try {
83155       result = Dali::Toolkit::TableView::New(arg1,arg2);
83156     } catch (std::out_of_range& e) {
83157       {
83158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83159       };
83160     } catch (std::exception& e) {
83161       {
83162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83163       };
83164     } catch (Dali::DaliException e) {
83165       {
83166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83167       };
83168     } catch (...) {
83169       {
83170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83171       };
83172     }
83173   }
83174
83175   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83176   return jresult;
83177 }
83178
83179
83180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83181   void * jresult ;
83182   Dali::BaseHandle arg1 ;
83183   Dali::BaseHandle *argp1 ;
83184   Dali::Toolkit::TableView result;
83185
83186   argp1 = (Dali::BaseHandle *)jarg1;
83187   if (!argp1) {
83188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83189     return 0;
83190   }
83191   arg1 = *argp1;
83192   {
83193     try {
83194       result = Dali::Toolkit::TableView::DownCast(arg1);
83195     } catch (std::out_of_range& e) {
83196       {
83197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83198       };
83199     } catch (std::exception& e) {
83200       {
83201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83202       };
83203     } catch (Dali::DaliException e) {
83204       {
83205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83206       };
83207     } catch (...) {
83208       {
83209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83210       };
83211     }
83212   }
83213
83214   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83215   return jresult;
83216 }
83217
83218
83219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83220   unsigned int jresult ;
83221   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83222   Dali::Actor arg2 ;
83223   Dali::Toolkit::TableView::CellPosition arg3 ;
83224   Dali::Actor *argp2 ;
83225   Dali::Toolkit::TableView::CellPosition *argp3 ;
83226   bool result;
83227
83228   arg1 = (Dali::Toolkit::TableView *)jarg1;
83229   argp2 = (Dali::Actor *)jarg2;
83230   if (!argp2) {
83231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83232     return 0;
83233   }
83234   arg2 = *argp2;
83235   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83236   if (!argp3) {
83237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83238     return 0;
83239   }
83240   arg3 = *argp3;
83241   {
83242     try {
83243       result = (bool)(arg1)->AddChild(arg2,arg3);
83244     } catch (std::out_of_range& e) {
83245       {
83246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83247       };
83248     } catch (std::exception& e) {
83249       {
83250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83251       };
83252     } catch (Dali::DaliException e) {
83253       {
83254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83255       };
83256     } catch (...) {
83257       {
83258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83259       };
83260     }
83261   }
83262
83263   jresult = result;
83264   return jresult;
83265 }
83266
83267
83268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83269   void * jresult ;
83270   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83271   Dali::Toolkit::TableView::CellPosition arg2 ;
83272   Dali::Toolkit::TableView::CellPosition *argp2 ;
83273   Dali::Actor result;
83274
83275   arg1 = (Dali::Toolkit::TableView *)jarg1;
83276   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83277   if (!argp2) {
83278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83279     return 0;
83280   }
83281   arg2 = *argp2;
83282   {
83283     try {
83284       result = (arg1)->GetChildAt(arg2);
83285     } catch (std::out_of_range& e) {
83286       {
83287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83288       };
83289     } catch (std::exception& e) {
83290       {
83291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83292       };
83293     } catch (Dali::DaliException e) {
83294       {
83295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83296       };
83297     } catch (...) {
83298       {
83299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83300       };
83301     }
83302   }
83303
83304   jresult = new Dali::Actor((const Dali::Actor &)result);
83305   return jresult;
83306 }
83307
83308
83309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83310   void * jresult ;
83311   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83312   Dali::Toolkit::TableView::CellPosition arg2 ;
83313   Dali::Toolkit::TableView::CellPosition *argp2 ;
83314   Dali::Actor result;
83315
83316   arg1 = (Dali::Toolkit::TableView *)jarg1;
83317   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83318   if (!argp2) {
83319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83320     return 0;
83321   }
83322   arg2 = *argp2;
83323   {
83324     try {
83325       result = (arg1)->RemoveChildAt(arg2);
83326     } catch (std::out_of_range& e) {
83327       {
83328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83329       };
83330     } catch (std::exception& e) {
83331       {
83332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83333       };
83334     } catch (Dali::DaliException e) {
83335       {
83336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83337       };
83338     } catch (...) {
83339       {
83340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83341       };
83342     }
83343   }
83344
83345   jresult = new Dali::Actor((const Dali::Actor &)result);
83346   return jresult;
83347 }
83348
83349
83350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83351   unsigned int jresult ;
83352   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83353   Dali::Actor arg2 ;
83354   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83355   Dali::Actor *argp2 ;
83356   bool result;
83357
83358   arg1 = (Dali::Toolkit::TableView *)jarg1;
83359   argp2 = (Dali::Actor *)jarg2;
83360   if (!argp2) {
83361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83362     return 0;
83363   }
83364   arg2 = *argp2;
83365   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83366   if (!arg3) {
83367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83368     return 0;
83369   }
83370   {
83371     try {
83372       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83373     } catch (std::out_of_range& e) {
83374       {
83375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83376       };
83377     } catch (std::exception& e) {
83378       {
83379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83380       };
83381     } catch (Dali::DaliException e) {
83382       {
83383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83384       };
83385     } catch (...) {
83386       {
83387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83388       };
83389     }
83390   }
83391
83392   jresult = result;
83393   return jresult;
83394 }
83395
83396
83397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83398   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83399   unsigned int arg2 ;
83400
83401   arg1 = (Dali::Toolkit::TableView *)jarg1;
83402   arg2 = (unsigned int)jarg2;
83403   {
83404     try {
83405       (arg1)->InsertRow(arg2);
83406     } catch (std::out_of_range& e) {
83407       {
83408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83409       };
83410     } catch (std::exception& e) {
83411       {
83412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83413       };
83414     } catch (Dali::DaliException e) {
83415       {
83416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83417       };
83418     } catch (...) {
83419       {
83420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83421       };
83422     }
83423   }
83424
83425 }
83426
83427
83428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83429   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83430   unsigned int arg2 ;
83431
83432   arg1 = (Dali::Toolkit::TableView *)jarg1;
83433   arg2 = (unsigned int)jarg2;
83434   {
83435     try {
83436       (arg1)->DeleteRow(arg2);
83437     } catch (std::out_of_range& e) {
83438       {
83439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83440       };
83441     } catch (std::exception& e) {
83442       {
83443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83444       };
83445     } catch (Dali::DaliException e) {
83446       {
83447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83448       };
83449     } catch (...) {
83450       {
83451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83452       };
83453     }
83454   }
83455
83456 }
83457
83458
83459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83460   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83461   unsigned int arg2 ;
83462   std::vector< Dali::Actor > *arg3 = 0 ;
83463
83464   arg1 = (Dali::Toolkit::TableView *)jarg1;
83465   arg2 = (unsigned int)jarg2;
83466   arg3 = (std::vector< Dali::Actor > *)jarg3;
83467   if (!arg3) {
83468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83469     return ;
83470   }
83471   {
83472     try {
83473       (arg1)->DeleteRow(arg2,*arg3);
83474     } catch (std::out_of_range& e) {
83475       {
83476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83477       };
83478     } catch (std::exception& e) {
83479       {
83480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83481       };
83482     } catch (Dali::DaliException e) {
83483       {
83484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83485       };
83486     } catch (...) {
83487       {
83488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83489       };
83490     }
83491   }
83492
83493 }
83494
83495
83496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83497   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83498   unsigned int arg2 ;
83499
83500   arg1 = (Dali::Toolkit::TableView *)jarg1;
83501   arg2 = (unsigned int)jarg2;
83502   {
83503     try {
83504       (arg1)->InsertColumn(arg2);
83505     } catch (std::out_of_range& e) {
83506       {
83507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83508       };
83509     } catch (std::exception& e) {
83510       {
83511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83512       };
83513     } catch (Dali::DaliException e) {
83514       {
83515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83516       };
83517     } catch (...) {
83518       {
83519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83520       };
83521     }
83522   }
83523
83524 }
83525
83526
83527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83528   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83529   unsigned int arg2 ;
83530
83531   arg1 = (Dali::Toolkit::TableView *)jarg1;
83532   arg2 = (unsigned int)jarg2;
83533   {
83534     try {
83535       (arg1)->DeleteColumn(arg2);
83536     } catch (std::out_of_range& e) {
83537       {
83538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83539       };
83540     } catch (std::exception& e) {
83541       {
83542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83543       };
83544     } catch (Dali::DaliException e) {
83545       {
83546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83547       };
83548     } catch (...) {
83549       {
83550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83551       };
83552     }
83553   }
83554
83555 }
83556
83557
83558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83559   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83560   unsigned int arg2 ;
83561   std::vector< Dali::Actor > *arg3 = 0 ;
83562
83563   arg1 = (Dali::Toolkit::TableView *)jarg1;
83564   arg2 = (unsigned int)jarg2;
83565   arg3 = (std::vector< Dali::Actor > *)jarg3;
83566   if (!arg3) {
83567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83568     return ;
83569   }
83570   {
83571     try {
83572       (arg1)->DeleteColumn(arg2,*arg3);
83573     } catch (std::out_of_range& e) {
83574       {
83575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83576       };
83577     } catch (std::exception& e) {
83578       {
83579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83580       };
83581     } catch (Dali::DaliException e) {
83582       {
83583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83584       };
83585     } catch (...) {
83586       {
83587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83588       };
83589     }
83590   }
83591
83592 }
83593
83594
83595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83596   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83597   unsigned int arg2 ;
83598   unsigned int arg3 ;
83599
83600   arg1 = (Dali::Toolkit::TableView *)jarg1;
83601   arg2 = (unsigned int)jarg2;
83602   arg3 = (unsigned int)jarg3;
83603   {
83604     try {
83605       (arg1)->Resize(arg2,arg3);
83606     } catch (std::out_of_range& e) {
83607       {
83608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83609       };
83610     } catch (std::exception& e) {
83611       {
83612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83613       };
83614     } catch (Dali::DaliException e) {
83615       {
83616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83617       };
83618     } catch (...) {
83619       {
83620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83621       };
83622     }
83623   }
83624
83625 }
83626
83627
83628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83629   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83630   unsigned int arg2 ;
83631   unsigned int arg3 ;
83632   std::vector< Dali::Actor > *arg4 = 0 ;
83633
83634   arg1 = (Dali::Toolkit::TableView *)jarg1;
83635   arg2 = (unsigned int)jarg2;
83636   arg3 = (unsigned int)jarg3;
83637   arg4 = (std::vector< Dali::Actor > *)jarg4;
83638   if (!arg4) {
83639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83640     return ;
83641   }
83642   {
83643     try {
83644       (arg1)->Resize(arg2,arg3,*arg4);
83645     } catch (std::out_of_range& e) {
83646       {
83647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83648       };
83649     } catch (std::exception& e) {
83650       {
83651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83652       };
83653     } catch (Dali::DaliException e) {
83654       {
83655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83656       };
83657     } catch (...) {
83658       {
83659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83660       };
83661     }
83662   }
83663
83664 }
83665
83666
83667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83668   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83669   Dali::Size arg2 ;
83670   Dali::Size *argp2 ;
83671
83672   arg1 = (Dali::Toolkit::TableView *)jarg1;
83673   argp2 = (Dali::Size *)jarg2;
83674   if (!argp2) {
83675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83676     return ;
83677   }
83678   arg2 = *argp2;
83679   {
83680     try {
83681       (arg1)->SetCellPadding(arg2);
83682     } catch (std::out_of_range& e) {
83683       {
83684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83685       };
83686     } catch (std::exception& e) {
83687       {
83688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83689       };
83690     } catch (Dali::DaliException e) {
83691       {
83692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83693       };
83694     } catch (...) {
83695       {
83696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83697       };
83698     }
83699   }
83700
83701 }
83702
83703
83704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83705   void * jresult ;
83706   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83707   Dali::Size result;
83708
83709   arg1 = (Dali::Toolkit::TableView *)jarg1;
83710   {
83711     try {
83712       result = (arg1)->GetCellPadding();
83713     } catch (std::out_of_range& e) {
83714       {
83715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83716       };
83717     } catch (std::exception& e) {
83718       {
83719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83720       };
83721     } catch (Dali::DaliException e) {
83722       {
83723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83724       };
83725     } catch (...) {
83726       {
83727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83728       };
83729     }
83730   }
83731
83732   jresult = new Dali::Size((const Dali::Size &)result);
83733   return jresult;
83734 }
83735
83736
83737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83738   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83739   unsigned int arg2 ;
83740
83741   arg1 = (Dali::Toolkit::TableView *)jarg1;
83742   arg2 = (unsigned int)jarg2;
83743   {
83744     try {
83745       (arg1)->SetFitHeight(arg2);
83746     } catch (std::out_of_range& e) {
83747       {
83748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83749       };
83750     } catch (std::exception& e) {
83751       {
83752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83753       };
83754     } catch (Dali::DaliException e) {
83755       {
83756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83757       };
83758     } catch (...) {
83759       {
83760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83761       };
83762     }
83763   }
83764
83765 }
83766
83767
83768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83769   unsigned int jresult ;
83770   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83771   unsigned int arg2 ;
83772   bool result;
83773
83774   arg1 = (Dali::Toolkit::TableView *)jarg1;
83775   arg2 = (unsigned int)jarg2;
83776   {
83777     try {
83778       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83779     } catch (std::out_of_range& e) {
83780       {
83781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83782       };
83783     } catch (std::exception& e) {
83784       {
83785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83786       };
83787     } catch (Dali::DaliException e) {
83788       {
83789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83790       };
83791     } catch (...) {
83792       {
83793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83794       };
83795     }
83796   }
83797
83798   jresult = result;
83799   return jresult;
83800 }
83801
83802
83803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83804   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83805   unsigned int arg2 ;
83806
83807   arg1 = (Dali::Toolkit::TableView *)jarg1;
83808   arg2 = (unsigned int)jarg2;
83809   {
83810     try {
83811       (arg1)->SetFitWidth(arg2);
83812     } catch (std::out_of_range& e) {
83813       {
83814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83815       };
83816     } catch (std::exception& e) {
83817       {
83818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83819       };
83820     } catch (Dali::DaliException e) {
83821       {
83822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83823       };
83824     } catch (...) {
83825       {
83826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83827       };
83828     }
83829   }
83830
83831 }
83832
83833
83834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83835   unsigned int jresult ;
83836   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83837   unsigned int arg2 ;
83838   bool result;
83839
83840   arg1 = (Dali::Toolkit::TableView *)jarg1;
83841   arg2 = (unsigned int)jarg2;
83842   {
83843     try {
83844       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83845     } catch (std::out_of_range& e) {
83846       {
83847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83848       };
83849     } catch (std::exception& e) {
83850       {
83851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83852       };
83853     } catch (Dali::DaliException e) {
83854       {
83855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83856       };
83857     } catch (...) {
83858       {
83859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83860       };
83861     }
83862   }
83863
83864   jresult = result;
83865   return jresult;
83866 }
83867
83868
83869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83870   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83871   unsigned int arg2 ;
83872   float arg3 ;
83873
83874   arg1 = (Dali::Toolkit::TableView *)jarg1;
83875   arg2 = (unsigned int)jarg2;
83876   arg3 = (float)jarg3;
83877   {
83878     try {
83879       (arg1)->SetFixedHeight(arg2,arg3);
83880     } catch (std::out_of_range& e) {
83881       {
83882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83883       };
83884     } catch (std::exception& e) {
83885       {
83886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83887       };
83888     } catch (Dali::DaliException e) {
83889       {
83890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83891       };
83892     } catch (...) {
83893       {
83894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83895       };
83896     }
83897   }
83898
83899 }
83900
83901
83902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83903   float jresult ;
83904   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83905   unsigned int arg2 ;
83906   float result;
83907
83908   arg1 = (Dali::Toolkit::TableView *)jarg1;
83909   arg2 = (unsigned int)jarg2;
83910   {
83911     try {
83912       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83913     } catch (std::out_of_range& e) {
83914       {
83915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83916       };
83917     } catch (std::exception& e) {
83918       {
83919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83920       };
83921     } catch (Dali::DaliException e) {
83922       {
83923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83924       };
83925     } catch (...) {
83926       {
83927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83928       };
83929     }
83930   }
83931
83932   jresult = result;
83933   return jresult;
83934 }
83935
83936
83937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83938   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83939   unsigned int arg2 ;
83940   float arg3 ;
83941
83942   arg1 = (Dali::Toolkit::TableView *)jarg1;
83943   arg2 = (unsigned int)jarg2;
83944   arg3 = (float)jarg3;
83945   {
83946     try {
83947       (arg1)->SetRelativeHeight(arg2,arg3);
83948     } catch (std::out_of_range& e) {
83949       {
83950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83951       };
83952     } catch (std::exception& e) {
83953       {
83954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83955       };
83956     } catch (Dali::DaliException e) {
83957       {
83958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83959       };
83960     } catch (...) {
83961       {
83962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83963       };
83964     }
83965   }
83966
83967 }
83968
83969
83970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83971   float jresult ;
83972   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83973   unsigned int arg2 ;
83974   float result;
83975
83976   arg1 = (Dali::Toolkit::TableView *)jarg1;
83977   arg2 = (unsigned int)jarg2;
83978   {
83979     try {
83980       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83981     } catch (std::out_of_range& e) {
83982       {
83983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83984       };
83985     } catch (std::exception& e) {
83986       {
83987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83988       };
83989     } catch (Dali::DaliException e) {
83990       {
83991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83992       };
83993     } catch (...) {
83994       {
83995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83996       };
83997     }
83998   }
83999
84000   jresult = result;
84001   return jresult;
84002 }
84003
84004
84005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84006   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84007   unsigned int arg2 ;
84008   float arg3 ;
84009
84010   arg1 = (Dali::Toolkit::TableView *)jarg1;
84011   arg2 = (unsigned int)jarg2;
84012   arg3 = (float)jarg3;
84013   {
84014     try {
84015       (arg1)->SetFixedWidth(arg2,arg3);
84016     } catch (std::out_of_range& e) {
84017       {
84018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84019       };
84020     } catch (std::exception& e) {
84021       {
84022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84023       };
84024     } catch (Dali::DaliException e) {
84025       {
84026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84027       };
84028     } catch (...) {
84029       {
84030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84031       };
84032     }
84033   }
84034
84035 }
84036
84037
84038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
84039   float jresult ;
84040   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84041   unsigned int arg2 ;
84042   float result;
84043
84044   arg1 = (Dali::Toolkit::TableView *)jarg1;
84045   arg2 = (unsigned int)jarg2;
84046   {
84047     try {
84048       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
84049     } catch (std::out_of_range& e) {
84050       {
84051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84052       };
84053     } catch (std::exception& e) {
84054       {
84055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84056       };
84057     } catch (Dali::DaliException e) {
84058       {
84059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84060       };
84061     } catch (...) {
84062       {
84063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84064       };
84065     }
84066   }
84067
84068   jresult = result;
84069   return jresult;
84070 }
84071
84072
84073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84074   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84075   unsigned int arg2 ;
84076   float arg3 ;
84077
84078   arg1 = (Dali::Toolkit::TableView *)jarg1;
84079   arg2 = (unsigned int)jarg2;
84080   arg3 = (float)jarg3;
84081   {
84082     try {
84083       (arg1)->SetRelativeWidth(arg2,arg3);
84084     } catch (std::out_of_range& e) {
84085       {
84086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84087       };
84088     } catch (std::exception& e) {
84089       {
84090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84091       };
84092     } catch (Dali::DaliException e) {
84093       {
84094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84095       };
84096     } catch (...) {
84097       {
84098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84099       };
84100     }
84101   }
84102
84103 }
84104
84105
84106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84107   float jresult ;
84108   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84109   unsigned int arg2 ;
84110   float result;
84111
84112   arg1 = (Dali::Toolkit::TableView *)jarg1;
84113   arg2 = (unsigned int)jarg2;
84114   {
84115     try {
84116       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84117     } catch (std::out_of_range& e) {
84118       {
84119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84120       };
84121     } catch (std::exception& e) {
84122       {
84123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84124       };
84125     } catch (Dali::DaliException e) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84128       };
84129     } catch (...) {
84130       {
84131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84132       };
84133     }
84134   }
84135
84136   jresult = result;
84137   return jresult;
84138 }
84139
84140
84141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84142   unsigned int jresult ;
84143   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84144   unsigned int result;
84145
84146   arg1 = (Dali::Toolkit::TableView *)jarg1;
84147   {
84148     try {
84149       result = (unsigned int)(arg1)->GetRows();
84150     } catch (std::out_of_range& e) {
84151       {
84152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84153       };
84154     } catch (std::exception& e) {
84155       {
84156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84157       };
84158     } catch (Dali::DaliException e) {
84159       {
84160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84161       };
84162     } catch (...) {
84163       {
84164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84165       };
84166     }
84167   }
84168
84169   jresult = result;
84170   return jresult;
84171 }
84172
84173
84174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84175   unsigned int jresult ;
84176   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84177   unsigned int result;
84178
84179   arg1 = (Dali::Toolkit::TableView *)jarg1;
84180   {
84181     try {
84182       result = (unsigned int)(arg1)->GetColumns();
84183     } catch (std::out_of_range& e) {
84184       {
84185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84186       };
84187     } catch (std::exception& e) {
84188       {
84189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84190       };
84191     } catch (Dali::DaliException e) {
84192       {
84193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84194       };
84195     } catch (...) {
84196       {
84197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84198       };
84199     }
84200   }
84201
84202   jresult = result;
84203   return jresult;
84204 }
84205
84206
84207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84208   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84209   Dali::Toolkit::TableView::CellPosition arg2 ;
84210   Dali::HorizontalAlignment::Type arg3 ;
84211   Dali::VerticalAlignment::Type arg4 ;
84212   Dali::Toolkit::TableView::CellPosition *argp2 ;
84213
84214   arg1 = (Dali::Toolkit::TableView *)jarg1;
84215   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84216   if (!argp2) {
84217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84218     return ;
84219   }
84220   arg2 = *argp2;
84221   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84222   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84223   {
84224     try {
84225       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84226     } catch (std::out_of_range& e) {
84227       {
84228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84229       };
84230     } catch (std::exception& e) {
84231       {
84232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84233       };
84234     } catch (Dali::DaliException e) {
84235       {
84236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84237       };
84238     } catch (...) {
84239       {
84240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84241       };
84242     }
84243   }
84244
84245 }
84246
84247
84248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84249   unsigned int jresult ;
84250   unsigned int result;
84251
84252   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84253   jresult = result;
84254   return jresult;
84255 }
84256
84257
84258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84259   int jresult ;
84260   int result;
84261
84262   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84263   jresult = (int)result;
84264   return jresult;
84265 }
84266
84267
84268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84269   int jresult ;
84270   int result;
84271
84272   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84273   jresult = (int)result;
84274   return jresult;
84275 }
84276
84277
84278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84279   int jresult ;
84280   int result;
84281
84282   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84283   jresult = (int)result;
84284   return jresult;
84285 }
84286
84287
84288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84289   int jresult ;
84290   int result;
84291
84292   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84293   jresult = (int)result;
84294   return jresult;
84295 }
84296
84297
84298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84299   int jresult ;
84300   int result;
84301
84302   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84303   jresult = (int)result;
84304   return jresult;
84305 }
84306
84307
84308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84309   int jresult ;
84310   int result;
84311
84312   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84313   jresult = (int)result;
84314   return jresult;
84315 }
84316
84317
84318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84319   int jresult ;
84320   int result;
84321
84322   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84323   jresult = (int)result;
84324   return jresult;
84325 }
84326
84327
84328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84329   int jresult ;
84330   int result;
84331
84332   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84333   jresult = (int)result;
84334   return jresult;
84335 }
84336
84337
84338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84339   int jresult ;
84340   int result;
84341
84342   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84343   jresult = (int)result;
84344   return jresult;
84345 }
84346
84347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
84348   int jresult ;
84349   int result;
84350
84351   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
84352   jresult = (int)result;
84353   return jresult;
84354 }
84355
84356
84357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
84358   int jresult ;
84359   int result;
84360
84361   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
84362   jresult = (int)result;
84363   return jresult;
84364 }
84365
84366
84367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
84368   int jresult ;
84369   int result;
84370
84371   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
84372   jresult = (int)result;
84373   return jresult;
84374 }
84375
84376
84377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
84378   int jresult ;
84379   int result;
84380
84381   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
84382   jresult = (int)result;
84383   return jresult;
84384 }
84385
84386
84387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
84388   int jresult ;
84389   int result;
84390
84391   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
84392   jresult = (int)result;
84393   return jresult;
84394 }
84395
84396
84397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84398   int jresult ;
84399   int result;
84400
84401   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84402   jresult = (int)result;
84403   return jresult;
84404 }
84405
84406
84407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84408   int jresult ;
84409   int result;
84410
84411   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84412   jresult = (int)result;
84413   return jresult;
84414 }
84415
84416
84417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84418   int jresult ;
84419   int result;
84420
84421   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84422   jresult = (int)result;
84423   return jresult;
84424 }
84425
84426
84427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84428   int jresult ;
84429   int result;
84430
84431   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84432   jresult = (int)result;
84433   return jresult;
84434 }
84435
84436
84437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84438   int jresult ;
84439   int result;
84440
84441   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84442   jresult = (int)result;
84443   return jresult;
84444 }
84445
84446
84447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84448   int jresult ;
84449   int result;
84450
84451   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84452   jresult = (int)result;
84453   return jresult;
84454 }
84455
84456
84457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84458   int jresult ;
84459   int result;
84460
84461   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84462   jresult = (int)result;
84463   return jresult;
84464 }
84465
84466
84467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84468   int jresult ;
84469   int result;
84470
84471   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84472   jresult = (int)result;
84473   return jresult;
84474 }
84475
84476
84477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84478   int jresult ;
84479   int result;
84480
84481   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84482   jresult = (int)result;
84483   return jresult;
84484 }
84485
84486
84487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84488   int jresult ;
84489   int result;
84490
84491   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84492   jresult = (int)result;
84493   return jresult;
84494 }
84495
84496
84497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84498   void * jresult ;
84499   Dali::Toolkit::TextLabel::Property *result = 0 ;
84500
84501   {
84502     try {
84503       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84504     } catch (std::out_of_range& e) {
84505       {
84506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84507       };
84508     } catch (std::exception& e) {
84509       {
84510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84511       };
84512     } catch (Dali::DaliException e) {
84513       {
84514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84515       };
84516     } catch (...) {
84517       {
84518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84519       };
84520     }
84521   }
84522
84523   jresult = (void *)result;
84524   return jresult;
84525 }
84526
84527
84528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84529   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84530
84531   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84532   {
84533     try {
84534       delete arg1;
84535     } catch (std::out_of_range& e) {
84536       {
84537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84538       };
84539     } catch (std::exception& e) {
84540       {
84541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84542       };
84543     } catch (Dali::DaliException e) {
84544       {
84545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84546       };
84547     } catch (...) {
84548       {
84549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84550       };
84551     }
84552   }
84553
84554 }
84555
84556
84557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84558   void * jresult ;
84559   Dali::Toolkit::TextLabel result;
84560
84561   {
84562     try {
84563       result = Dali::Toolkit::TextLabel::New();
84564     } catch (std::out_of_range& e) {
84565       {
84566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84567       };
84568     } catch (std::exception& e) {
84569       {
84570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84571       };
84572     } catch (Dali::DaliException e) {
84573       {
84574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84575       };
84576     } catch (...) {
84577       {
84578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84579       };
84580     }
84581   }
84582
84583   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84584   return jresult;
84585 }
84586
84587
84588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84589   void * jresult ;
84590   std::string *arg1 = 0 ;
84591   Dali::Toolkit::TextLabel result;
84592
84593   if (!jarg1) {
84594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84595     return 0;
84596   }
84597   std::string arg1_str(jarg1);
84598   arg1 = &arg1_str;
84599   {
84600     try {
84601       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84602     } catch (std::out_of_range& e) {
84603       {
84604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84605       };
84606     } catch (std::exception& e) {
84607       {
84608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84609       };
84610     } catch (Dali::DaliException e) {
84611       {
84612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84613       };
84614     } catch (...) {
84615       {
84616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84617       };
84618     }
84619   }
84620
84621   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84622
84623   //argout typemap for const std::string&
84624
84625   return jresult;
84626 }
84627
84628
84629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84630   void * jresult ;
84631   Dali::Toolkit::TextLabel *result = 0 ;
84632
84633   {
84634     try {
84635       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84636     } catch (std::out_of_range& e) {
84637       {
84638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84639       };
84640     } catch (std::exception& e) {
84641       {
84642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84643       };
84644     } catch (Dali::DaliException e) {
84645       {
84646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84647       };
84648     } catch (...) {
84649       {
84650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84651       };
84652     }
84653   }
84654
84655   jresult = (void *)result;
84656   return jresult;
84657 }
84658
84659
84660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84661   void * jresult ;
84662   Dali::Toolkit::TextLabel *arg1 = 0 ;
84663   Dali::Toolkit::TextLabel *result = 0 ;
84664
84665   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84666   if (!arg1) {
84667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84668     return 0;
84669   }
84670   {
84671     try {
84672       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84673     } catch (std::out_of_range& e) {
84674       {
84675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84676       };
84677     } catch (std::exception& e) {
84678       {
84679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84680       };
84681     } catch (Dali::DaliException e) {
84682       {
84683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84684       };
84685     } catch (...) {
84686       {
84687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84688       };
84689     }
84690   }
84691
84692   jresult = (void *)result;
84693   return jresult;
84694 }
84695
84696
84697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84698   void * jresult ;
84699   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84700   Dali::Toolkit::TextLabel *arg2 = 0 ;
84701   Dali::Toolkit::TextLabel *result = 0 ;
84702
84703   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84704   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84705   if (!arg2) {
84706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84707     return 0;
84708   }
84709   {
84710     try {
84711       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84712     } catch (std::out_of_range& e) {
84713       {
84714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84715       };
84716     } catch (std::exception& e) {
84717       {
84718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84719       };
84720     } catch (Dali::DaliException e) {
84721       {
84722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84723       };
84724     } catch (...) {
84725       {
84726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84727       };
84728     }
84729   }
84730
84731   jresult = (void *)result;
84732   return jresult;
84733 }
84734
84735
84736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84737   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84738
84739   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84740   {
84741     try {
84742       delete arg1;
84743     } catch (std::out_of_range& e) {
84744       {
84745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84746       };
84747     } catch (std::exception& e) {
84748       {
84749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84750       };
84751     } catch (Dali::DaliException e) {
84752       {
84753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84754       };
84755     } catch (...) {
84756       {
84757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84758       };
84759     }
84760   }
84761
84762 }
84763
84764
84765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84766   void * jresult ;
84767   Dali::BaseHandle arg1 ;
84768   Dali::BaseHandle *argp1 ;
84769   Dali::Toolkit::TextLabel result;
84770
84771   argp1 = (Dali::BaseHandle *)jarg1;
84772   if (!argp1) {
84773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84774     return 0;
84775   }
84776   arg1 = *argp1;
84777   {
84778     try {
84779       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84780     } catch (std::out_of_range& e) {
84781       {
84782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84783       };
84784     } catch (std::exception& e) {
84785       {
84786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84787       };
84788     } catch (Dali::DaliException e) {
84789       {
84790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84791       };
84792     } catch (...) {
84793       {
84794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84795       };
84796     }
84797   }
84798
84799   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84800   return jresult;
84801 }
84802
84803
84804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84805   void * jresult ;
84806   Dali::Toolkit::AccessibilityManager *result = 0 ;
84807
84808   {
84809     try {
84810       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84811     } catch (std::out_of_range& e) {
84812       {
84813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84814       };
84815     } catch (std::exception& e) {
84816       {
84817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84818       };
84819     } catch (Dali::DaliException e) {
84820       {
84821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84822       };
84823     } catch (...) {
84824       {
84825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84826       };
84827     }
84828   }
84829
84830   jresult = (void *)result;
84831   return jresult;
84832 }
84833
84834
84835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84836   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84837
84838   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84839   {
84840     try {
84841       delete arg1;
84842     } catch (std::out_of_range& e) {
84843       {
84844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84845       };
84846     } catch (std::exception& e) {
84847       {
84848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84849       };
84850     } catch (Dali::DaliException e) {
84851       {
84852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84853       };
84854     } catch (...) {
84855       {
84856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84857       };
84858     }
84859   }
84860
84861 }
84862
84863
84864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84865   void * jresult ;
84866   Dali::Toolkit::AccessibilityManager result;
84867
84868   {
84869     try {
84870       result = Dali::Toolkit::AccessibilityManager::Get();
84871     } catch (std::out_of_range& e) {
84872       {
84873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84874       };
84875     } catch (std::exception& e) {
84876       {
84877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84878       };
84879     } catch (Dali::DaliException e) {
84880       {
84881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84882       };
84883     } catch (...) {
84884       {
84885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84886       };
84887     }
84888   }
84889
84890   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84891   return jresult;
84892 }
84893
84894
84895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84896   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84897   Dali::Actor arg2 ;
84898   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84899   std::string *arg4 = 0 ;
84900   Dali::Actor *argp2 ;
84901
84902   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84903   argp2 = (Dali::Actor *)jarg2;
84904   if (!argp2) {
84905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84906     return ;
84907   }
84908   arg2 = *argp2;
84909   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84910   if (!jarg4) {
84911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84912     return ;
84913   }
84914   std::string arg4_str(jarg4);
84915   arg4 = &arg4_str;
84916   {
84917     try {
84918       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84919     } catch (std::out_of_range& e) {
84920       {
84921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84922       };
84923     } catch (std::exception& e) {
84924       {
84925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84926       };
84927     } catch (Dali::DaliException e) {
84928       {
84929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84930       };
84931     } catch (...) {
84932       {
84933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84934       };
84935     }
84936   }
84937
84938
84939   //argout typemap for const std::string&
84940
84941 }
84942
84943
84944 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84945   char * jresult ;
84946   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84947   Dali::Actor arg2 ;
84948   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84949   Dali::Actor *argp2 ;
84950   std::string result;
84951
84952   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84953   argp2 = (Dali::Actor *)jarg2;
84954   if (!argp2) {
84955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84956     return 0;
84957   }
84958   arg2 = *argp2;
84959   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84960   {
84961     try {
84962       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84963     } catch (std::out_of_range& e) {
84964       {
84965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84966       };
84967     } catch (std::exception& e) {
84968       {
84969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84970       };
84971     } catch (Dali::DaliException e) {
84972       {
84973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84974       };
84975     } catch (...) {
84976       {
84977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84978       };
84979     }
84980   }
84981
84982   jresult = SWIG_csharp_string_callback((&result)->c_str());
84983   return jresult;
84984 }
84985
84986
84987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84988   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84989   Dali::Actor arg2 ;
84990   unsigned int arg3 ;
84991   Dali::Actor *argp2 ;
84992
84993   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84994   argp2 = (Dali::Actor *)jarg2;
84995   if (!argp2) {
84996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84997     return ;
84998   }
84999   arg2 = *argp2;
85000   arg3 = (unsigned int)jarg3;
85001   {
85002     try {
85003       (arg1)->SetFocusOrder(arg2,arg3);
85004     } catch (std::out_of_range& e) {
85005       {
85006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85007       };
85008     } catch (std::exception& e) {
85009       {
85010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85011       };
85012     } catch (Dali::DaliException e) {
85013       {
85014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85015       };
85016     } catch (...) {
85017       {
85018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85019       };
85020     }
85021   }
85022
85023 }
85024
85025
85026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
85027   unsigned int jresult ;
85028   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85029   Dali::Actor arg2 ;
85030   Dali::Actor *argp2 ;
85031   unsigned int result;
85032
85033   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85034   argp2 = (Dali::Actor *)jarg2;
85035   if (!argp2) {
85036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85037     return 0;
85038   }
85039   arg2 = *argp2;
85040   {
85041     try {
85042       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
85043     } catch (std::out_of_range& e) {
85044       {
85045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85046       };
85047     } catch (std::exception& e) {
85048       {
85049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85050       };
85051     } catch (Dali::DaliException e) {
85052       {
85053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85054       };
85055     } catch (...) {
85056       {
85057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85058       };
85059     }
85060   }
85061
85062   jresult = result;
85063   return jresult;
85064 }
85065
85066
85067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
85068   unsigned int jresult ;
85069   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85070   unsigned int result;
85071
85072   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85073   {
85074     try {
85075       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85076     } catch (std::out_of_range& e) {
85077       {
85078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85079       };
85080     } catch (std::exception& e) {
85081       {
85082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85083       };
85084     } catch (Dali::DaliException e) {
85085       {
85086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85087       };
85088     } catch (...) {
85089       {
85090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85091       };
85092     }
85093   }
85094
85095   jresult = result;
85096   return jresult;
85097 }
85098
85099
85100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85101   void * jresult ;
85102   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85103   unsigned int arg2 ;
85104   Dali::Actor result;
85105
85106   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85107   arg2 = (unsigned int)jarg2;
85108   {
85109     try {
85110       result = (arg1)->GetActorByFocusOrder(arg2);
85111     } catch (std::out_of_range& e) {
85112       {
85113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85114       };
85115     } catch (std::exception& e) {
85116       {
85117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85118       };
85119     } catch (Dali::DaliException e) {
85120       {
85121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85122       };
85123     } catch (...) {
85124       {
85125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85126       };
85127     }
85128   }
85129
85130   jresult = new Dali::Actor((const Dali::Actor &)result);
85131   return jresult;
85132 }
85133
85134
85135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85136   unsigned int jresult ;
85137   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85138   Dali::Actor arg2 ;
85139   Dali::Actor *argp2 ;
85140   bool result;
85141
85142   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85143   argp2 = (Dali::Actor *)jarg2;
85144   if (!argp2) {
85145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85146     return 0;
85147   }
85148   arg2 = *argp2;
85149   {
85150     try {
85151       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85152     } catch (std::out_of_range& e) {
85153       {
85154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85155       };
85156     } catch (std::exception& e) {
85157       {
85158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85159       };
85160     } catch (Dali::DaliException e) {
85161       {
85162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85163       };
85164     } catch (...) {
85165       {
85166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85167       };
85168     }
85169   }
85170
85171   jresult = result;
85172   return jresult;
85173 }
85174
85175
85176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85177   void * jresult ;
85178   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85179   Dali::Actor result;
85180
85181   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85182   {
85183     try {
85184       result = (arg1)->GetCurrentFocusActor();
85185     } catch (std::out_of_range& e) {
85186       {
85187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85188       };
85189     } catch (std::exception& e) {
85190       {
85191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85192       };
85193     } catch (Dali::DaliException e) {
85194       {
85195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85196       };
85197     } catch (...) {
85198       {
85199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85200       };
85201     }
85202   }
85203
85204   jresult = new Dali::Actor((const Dali::Actor &)result);
85205   return jresult;
85206 }
85207
85208
85209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85210   void * jresult ;
85211   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85212   Dali::Actor result;
85213
85214   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85215   {
85216     try {
85217       result = (arg1)->GetCurrentFocusGroup();
85218     } catch (std::out_of_range& e) {
85219       {
85220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85221       };
85222     } catch (std::exception& e) {
85223       {
85224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85225       };
85226     } catch (Dali::DaliException e) {
85227       {
85228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85229       };
85230     } catch (...) {
85231       {
85232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85233       };
85234     }
85235   }
85236
85237   jresult = new Dali::Actor((const Dali::Actor &)result);
85238   return jresult;
85239 }
85240
85241
85242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85243   unsigned int jresult ;
85244   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85245   unsigned int result;
85246
85247   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85248   {
85249     try {
85250       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85251     } catch (std::out_of_range& e) {
85252       {
85253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85254       };
85255     } catch (std::exception& e) {
85256       {
85257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85258       };
85259     } catch (Dali::DaliException e) {
85260       {
85261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85262       };
85263     } catch (...) {
85264       {
85265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85266       };
85267     }
85268   }
85269
85270   jresult = result;
85271   return jresult;
85272 }
85273
85274
85275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85276   unsigned int jresult ;
85277   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85278   bool result;
85279
85280   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85281   {
85282     try {
85283       result = (bool)(arg1)->MoveFocusForward();
85284     } catch (std::out_of_range& e) {
85285       {
85286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85287       };
85288     } catch (std::exception& e) {
85289       {
85290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85291       };
85292     } catch (Dali::DaliException e) {
85293       {
85294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85295       };
85296     } catch (...) {
85297       {
85298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85299       };
85300     }
85301   }
85302
85303   jresult = result;
85304   return jresult;
85305 }
85306
85307
85308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85309   unsigned int jresult ;
85310   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85311   bool result;
85312
85313   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85314   {
85315     try {
85316       result = (bool)(arg1)->MoveFocusBackward();
85317     } catch (std::out_of_range& e) {
85318       {
85319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85320       };
85321     } catch (std::exception& e) {
85322       {
85323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85324       };
85325     } catch (Dali::DaliException e) {
85326       {
85327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85328       };
85329     } catch (...) {
85330       {
85331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85332       };
85333     }
85334   }
85335
85336   jresult = result;
85337   return jresult;
85338 }
85339
85340
85341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85342   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85343
85344   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85345   {
85346     try {
85347       (arg1)->ClearFocus();
85348     } catch (std::out_of_range& e) {
85349       {
85350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85351       };
85352     } catch (std::exception& e) {
85353       {
85354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85355       };
85356     } catch (Dali::DaliException e) {
85357       {
85358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85359       };
85360     } catch (...) {
85361       {
85362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85363       };
85364     }
85365   }
85366
85367 }
85368
85369
85370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85371   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85372
85373   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85374   {
85375     try {
85376       (arg1)->Reset();
85377     } catch (std::out_of_range& e) {
85378       {
85379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85380       };
85381     } catch (std::exception& e) {
85382       {
85383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85384       };
85385     } catch (Dali::DaliException e) {
85386       {
85387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85388       };
85389     } catch (...) {
85390       {
85391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85392       };
85393     }
85394   }
85395
85396 }
85397
85398
85399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85400   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85401   Dali::Actor arg2 ;
85402   bool arg3 ;
85403   Dali::Actor *argp2 ;
85404
85405   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85406   argp2 = (Dali::Actor *)jarg2;
85407   if (!argp2) {
85408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85409     return ;
85410   }
85411   arg2 = *argp2;
85412   arg3 = jarg3 ? true : false;
85413   {
85414     try {
85415       (arg1)->SetFocusGroup(arg2,arg3);
85416     } catch (std::out_of_range& e) {
85417       {
85418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85419       };
85420     } catch (std::exception& e) {
85421       {
85422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85423       };
85424     } catch (Dali::DaliException e) {
85425       {
85426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85427       };
85428     } catch (...) {
85429       {
85430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85431       };
85432     }
85433   }
85434
85435 }
85436
85437
85438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85439   unsigned int jresult ;
85440   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85441   Dali::Actor arg2 ;
85442   Dali::Actor *argp2 ;
85443   bool result;
85444
85445   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85446   argp2 = (Dali::Actor *)jarg2;
85447   if (!argp2) {
85448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85449     return 0;
85450   }
85451   arg2 = *argp2;
85452   {
85453     try {
85454       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85455     } catch (std::out_of_range& e) {
85456       {
85457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85458       };
85459     } catch (std::exception& e) {
85460       {
85461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85462       };
85463     } catch (Dali::DaliException e) {
85464       {
85465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85466       };
85467     } catch (...) {
85468       {
85469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85470       };
85471     }
85472   }
85473
85474   jresult = result;
85475   return jresult;
85476 }
85477
85478
85479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85480   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85481   bool arg2 ;
85482
85483   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85484   arg2 = jarg2 ? true : false;
85485   {
85486     try {
85487       (arg1)->SetGroupMode(arg2);
85488     } catch (std::out_of_range& e) {
85489       {
85490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85491       };
85492     } catch (std::exception& e) {
85493       {
85494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85495       };
85496     } catch (Dali::DaliException e) {
85497       {
85498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85499       };
85500     } catch (...) {
85501       {
85502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85503       };
85504     }
85505   }
85506
85507 }
85508
85509
85510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85511   unsigned int jresult ;
85512   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85513   bool result;
85514
85515   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85516   {
85517     try {
85518       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85519     } catch (std::out_of_range& e) {
85520       {
85521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85522       };
85523     } catch (std::exception& e) {
85524       {
85525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85526       };
85527     } catch (Dali::DaliException e) {
85528       {
85529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85530       };
85531     } catch (...) {
85532       {
85533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85534       };
85535     }
85536   }
85537
85538   jresult = result;
85539   return jresult;
85540 }
85541
85542
85543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85544   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85545   bool arg2 ;
85546
85547   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85548   arg2 = jarg2 ? true : false;
85549   {
85550     try {
85551       (arg1)->SetWrapMode(arg2);
85552     } catch (std::out_of_range& e) {
85553       {
85554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85555       };
85556     } catch (std::exception& e) {
85557       {
85558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85559       };
85560     } catch (Dali::DaliException e) {
85561       {
85562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85563       };
85564     } catch (...) {
85565       {
85566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85567       };
85568     }
85569   }
85570
85571 }
85572
85573
85574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85575   unsigned int jresult ;
85576   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85577   bool result;
85578
85579   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85580   {
85581     try {
85582       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85583     } catch (std::out_of_range& e) {
85584       {
85585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85586       };
85587     } catch (std::exception& e) {
85588       {
85589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85590       };
85591     } catch (Dali::DaliException e) {
85592       {
85593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85594       };
85595     } catch (...) {
85596       {
85597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85598       };
85599     }
85600   }
85601
85602   jresult = result;
85603   return jresult;
85604 }
85605
85606
85607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85608   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85609   Dali::Actor arg2 ;
85610   Dali::Actor *argp2 ;
85611
85612   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85613   argp2 = (Dali::Actor *)jarg2;
85614   if (!argp2) {
85615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85616     return ;
85617   }
85618   arg2 = *argp2;
85619   {
85620     try {
85621       (arg1)->SetFocusIndicatorActor(arg2);
85622     } catch (std::out_of_range& e) {
85623       {
85624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85625       };
85626     } catch (std::exception& e) {
85627       {
85628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85629       };
85630     } catch (Dali::DaliException e) {
85631       {
85632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85633       };
85634     } catch (...) {
85635       {
85636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85637       };
85638     }
85639   }
85640
85641 }
85642
85643
85644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85645   void * jresult ;
85646   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85647   Dali::Actor result;
85648
85649   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85650   {
85651     try {
85652       result = (arg1)->GetFocusIndicatorActor();
85653     } catch (std::out_of_range& e) {
85654       {
85655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85656       };
85657     } catch (std::exception& e) {
85658       {
85659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85660       };
85661     } catch (Dali::DaliException e) {
85662       {
85663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85664       };
85665     } catch (...) {
85666       {
85667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85668       };
85669     }
85670   }
85671
85672   jresult = new Dali::Actor((const Dali::Actor &)result);
85673   return jresult;
85674 }
85675
85676
85677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85678   void * jresult ;
85679   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85680   Dali::Actor arg2 ;
85681   Dali::Actor *argp2 ;
85682   Dali::Actor result;
85683
85684   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85685   argp2 = (Dali::Actor *)jarg2;
85686   if (!argp2) {
85687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85688     return 0;
85689   }
85690   arg2 = *argp2;
85691   {
85692     try {
85693       result = (arg1)->GetFocusGroup(arg2);
85694     } catch (std::out_of_range& e) {
85695       {
85696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85697       };
85698     } catch (std::exception& e) {
85699       {
85700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85701       };
85702     } catch (Dali::DaliException e) {
85703       {
85704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85705       };
85706     } catch (...) {
85707       {
85708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85709       };
85710     }
85711   }
85712
85713   jresult = new Dali::Actor((const Dali::Actor &)result);
85714   return jresult;
85715 }
85716
85717
85718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85719   void * jresult ;
85720   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85721   Dali::Vector2 result;
85722
85723   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85724   {
85725     try {
85726       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85727     } catch (std::out_of_range& e) {
85728       {
85729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85730       };
85731     } catch (std::exception& e) {
85732       {
85733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85734       };
85735     } catch (Dali::DaliException e) {
85736       {
85737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85738       };
85739     } catch (...) {
85740       {
85741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85742       };
85743     }
85744   }
85745
85746   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85747   return jresult;
85748 }
85749
85750
85751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85752   void * jresult ;
85753   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85754   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85755
85756   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85757   {
85758     try {
85759       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85760     } catch (std::out_of_range& e) {
85761       {
85762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85763       };
85764     } catch (std::exception& e) {
85765       {
85766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85767       };
85768     } catch (Dali::DaliException e) {
85769       {
85770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85771       };
85772     } catch (...) {
85773       {
85774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85775       };
85776     }
85777   }
85778
85779   jresult = (void *)result;
85780   return jresult;
85781 }
85782
85783
85784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85785   void * jresult ;
85786   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85787   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85788
85789   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85790   {
85791     try {
85792       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85793     } catch (std::out_of_range& e) {
85794       {
85795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85796       };
85797     } catch (std::exception& e) {
85798       {
85799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85800       };
85801     } catch (Dali::DaliException e) {
85802       {
85803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85804       };
85805     } catch (...) {
85806       {
85807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85808       };
85809     }
85810   }
85811
85812   jresult = (void *)result;
85813   return jresult;
85814 }
85815
85816
85817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85818   void * jresult ;
85819   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85820   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85821
85822   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85823   {
85824     try {
85825       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85826     } catch (std::out_of_range& e) {
85827       {
85828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85829       };
85830     } catch (std::exception& e) {
85831       {
85832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85833       };
85834     } catch (Dali::DaliException e) {
85835       {
85836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85837       };
85838     } catch (...) {
85839       {
85840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85841       };
85842     }
85843   }
85844
85845   jresult = (void *)result;
85846   return jresult;
85847 }
85848
85849
85850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85851   void * jresult ;
85852   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85853   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85854
85855   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85856   {
85857     try {
85858       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85859     } catch (std::out_of_range& e) {
85860       {
85861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85862       };
85863     } catch (std::exception& e) {
85864       {
85865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85866       };
85867     } catch (Dali::DaliException e) {
85868       {
85869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85870       };
85871     } catch (...) {
85872       {
85873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85874       };
85875     }
85876   }
85877
85878   jresult = (void *)result;
85879   return jresult;
85880 }
85881
85882
85883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85884   void * jresult ;
85885   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85886   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85887
85888   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85889   {
85890     try {
85891       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85892     } catch (std::out_of_range& e) {
85893       {
85894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85895       };
85896     } catch (std::exception& e) {
85897       {
85898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85899       };
85900     } catch (Dali::DaliException e) {
85901       {
85902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85903       };
85904     } catch (...) {
85905       {
85906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85907       };
85908     }
85909   }
85910
85911   jresult = (void *)result;
85912   return jresult;
85913 }
85914
85915
85916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85917   void * jresult ;
85918   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85919   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85920
85921   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85922   {
85923     try {
85924       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85925     } catch (std::out_of_range& e) {
85926       {
85927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85928       };
85929     } catch (std::exception& e) {
85930       {
85931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85932       };
85933     } catch (Dali::DaliException e) {
85934       {
85935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85936       };
85937     } catch (...) {
85938       {
85939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85940       };
85941     }
85942   }
85943
85944   jresult = (void *)result;
85945   return jresult;
85946 }
85947
85948
85949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85950   void * jresult ;
85951   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85952   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85953
85954   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85955   {
85956     try {
85957       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85958     } catch (std::out_of_range& e) {
85959       {
85960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85961       };
85962     } catch (std::exception& e) {
85963       {
85964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85965       };
85966     } catch (Dali::DaliException e) {
85967       {
85968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85969       };
85970     } catch (...) {
85971       {
85972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85973       };
85974     }
85975   }
85976
85977   jresult = (void *)result;
85978   return jresult;
85979 }
85980
85981
85982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85983   void * jresult ;
85984   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85985   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85986
85987   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85988   {
85989     try {
85990       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85991     } catch (std::out_of_range& e) {
85992       {
85993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85994       };
85995     } catch (std::exception& e) {
85996       {
85997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85998       };
85999     } catch (Dali::DaliException e) {
86000       {
86001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86002       };
86003     } catch (...) {
86004       {
86005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86006       };
86007     }
86008   }
86009
86010   jresult = (void *)result;
86011   return jresult;
86012 }
86013
86014
86015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
86016   void * jresult ;
86017   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86018   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86019
86020   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86021   {
86022     try {
86023       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
86024     } catch (std::out_of_range& e) {
86025       {
86026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86027       };
86028     } catch (std::exception& e) {
86029       {
86030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86031       };
86032     } catch (Dali::DaliException e) {
86033       {
86034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86035       };
86036     } catch (...) {
86037       {
86038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86039       };
86040     }
86041   }
86042
86043   jresult = (void *)result;
86044   return jresult;
86045 }
86046
86047
86048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
86049   void * jresult ;
86050   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86051   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86052
86053   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86054   {
86055     try {
86056       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
86057     } catch (std::out_of_range& e) {
86058       {
86059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86060       };
86061     } catch (std::exception& e) {
86062       {
86063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86064       };
86065     } catch (Dali::DaliException e) {
86066       {
86067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86068       };
86069     } catch (...) {
86070       {
86071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86072       };
86073     }
86074   }
86075
86076   jresult = (void *)result;
86077   return jresult;
86078 }
86079
86080
86081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86082   void * jresult ;
86083   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86084   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86085
86086   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86087   {
86088     try {
86089       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86090     } catch (std::out_of_range& e) {
86091       {
86092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86093       };
86094     } catch (std::exception& e) {
86095       {
86096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86097       };
86098     } catch (Dali::DaliException e) {
86099       {
86100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86101       };
86102     } catch (...) {
86103       {
86104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86105       };
86106     }
86107   }
86108
86109   jresult = (void *)result;
86110   return jresult;
86111 }
86112
86113
86114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86115   void * jresult ;
86116   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86117   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86118
86119   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86120   {
86121     try {
86122       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86123     } catch (std::out_of_range& e) {
86124       {
86125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86126       };
86127     } catch (std::exception& e) {
86128       {
86129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86130       };
86131     } catch (Dali::DaliException e) {
86132       {
86133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86134       };
86135     } catch (...) {
86136       {
86137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86138       };
86139     }
86140   }
86141
86142   jresult = (void *)result;
86143   return jresult;
86144 }
86145
86146
86147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86148   void * jresult ;
86149   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86150   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86151
86152   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86153   {
86154     try {
86155       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86156     } catch (std::out_of_range& e) {
86157       {
86158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86159       };
86160     } catch (std::exception& e) {
86161       {
86162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86163       };
86164     } catch (Dali::DaliException e) {
86165       {
86166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86167       };
86168     } catch (...) {
86169       {
86170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86171       };
86172     }
86173   }
86174
86175   jresult = (void *)result;
86176   return jresult;
86177 }
86178
86179
86180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86181   void * jresult ;
86182   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86183   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86184
86185   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86186   {
86187     try {
86188       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86189     } catch (std::out_of_range& e) {
86190       {
86191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86192       };
86193     } catch (std::exception& e) {
86194       {
86195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86196       };
86197     } catch (Dali::DaliException e) {
86198       {
86199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86200       };
86201     } catch (...) {
86202       {
86203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86204       };
86205     }
86206   }
86207
86208   jresult = (void *)result;
86209   return jresult;
86210 }
86211
86212
86213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86214   void * jresult ;
86215   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86216   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86217
86218   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86219   {
86220     try {
86221       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86222     } catch (std::out_of_range& e) {
86223       {
86224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86225       };
86226     } catch (std::exception& e) {
86227       {
86228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86229       };
86230     } catch (Dali::DaliException e) {
86231       {
86232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86233       };
86234     } catch (...) {
86235       {
86236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86237       };
86238     }
86239   }
86240
86241   jresult = (void *)result;
86242   return jresult;
86243 }
86244
86245
86246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86247   void * jresult ;
86248   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86249   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86250
86251   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86252   {
86253     try {
86254       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86255     } catch (std::out_of_range& e) {
86256       {
86257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86258       };
86259     } catch (std::exception& e) {
86260       {
86261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86262       };
86263     } catch (Dali::DaliException e) {
86264       {
86265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86266       };
86267     } catch (...) {
86268       {
86269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86270       };
86271     }
86272   }
86273
86274   jresult = (void *)result;
86275   return jresult;
86276 }
86277
86278
86279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86280   void * jresult ;
86281   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86282   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86283
86284   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86285   {
86286     try {
86287       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86288     } catch (std::out_of_range& e) {
86289       {
86290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86291       };
86292     } catch (std::exception& e) {
86293       {
86294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86295       };
86296     } catch (Dali::DaliException e) {
86297       {
86298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86299       };
86300     } catch (...) {
86301       {
86302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86303       };
86304     }
86305   }
86306
86307   jresult = (void *)result;
86308   return jresult;
86309 }
86310
86311
86312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86313   void * jresult ;
86314   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86315   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86316
86317   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86318   {
86319     try {
86320       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86321     } catch (std::out_of_range& e) {
86322       {
86323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86324       };
86325     } catch (std::exception& e) {
86326       {
86327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86328       };
86329     } catch (Dali::DaliException e) {
86330       {
86331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86332       };
86333     } catch (...) {
86334       {
86335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86336       };
86337     }
86338   }
86339
86340   jresult = (void *)result;
86341   return jresult;
86342 }
86343
86344
86345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86346   void * jresult ;
86347   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86348   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86349
86350   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86351   {
86352     try {
86353       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86354     } catch (std::out_of_range& e) {
86355       {
86356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86357       };
86358     } catch (std::exception& e) {
86359       {
86360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86361       };
86362     } catch (Dali::DaliException e) {
86363       {
86364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86365       };
86366     } catch (...) {
86367       {
86368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86369       };
86370     }
86371   }
86372
86373   jresult = (void *)result;
86374   return jresult;
86375 }
86376
86377
86378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86379   void * jresult ;
86380   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86381   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86382
86383   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86384   {
86385     try {
86386       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86387     } catch (std::out_of_range& e) {
86388       {
86389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86390       };
86391     } catch (std::exception& e) {
86392       {
86393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86394       };
86395     } catch (Dali::DaliException e) {
86396       {
86397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86398       };
86399     } catch (...) {
86400       {
86401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86402       };
86403     }
86404   }
86405
86406   jresult = (void *)result;
86407   return jresult;
86408 }
86409
86410
86411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86412   void * jresult ;
86413   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86414   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86415
86416   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86417   {
86418     try {
86419       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86420     } catch (std::out_of_range& e) {
86421       {
86422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86423       };
86424     } catch (std::exception& e) {
86425       {
86426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86427       };
86428     } catch (Dali::DaliException e) {
86429       {
86430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86431       };
86432     } catch (...) {
86433       {
86434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86435       };
86436     }
86437   }
86438
86439   jresult = (void *)result;
86440   return jresult;
86441 }
86442
86443
86444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86445   void * jresult ;
86446   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86447   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86448
86449   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86450   {
86451     try {
86452       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86453     } catch (std::out_of_range& e) {
86454       {
86455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86456       };
86457     } catch (std::exception& e) {
86458       {
86459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86460       };
86461     } catch (Dali::DaliException e) {
86462       {
86463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86464       };
86465     } catch (...) {
86466       {
86467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86468       };
86469     }
86470   }
86471
86472   jresult = (void *)result;
86473   return jresult;
86474 }
86475
86476
86477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86478   void * jresult ;
86479   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86480   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86481
86482   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86483   {
86484     try {
86485       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86486     } catch (std::out_of_range& e) {
86487       {
86488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86489       };
86490     } catch (std::exception& e) {
86491       {
86492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86493       };
86494     } catch (Dali::DaliException e) {
86495       {
86496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86497       };
86498     } catch (...) {
86499       {
86500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86501       };
86502     }
86503   }
86504
86505   jresult = (void *)result;
86506   return jresult;
86507 }
86508
86509
86510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86511   void * jresult ;
86512   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86513   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86514
86515   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86516   {
86517     try {
86518       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86519     } catch (std::out_of_range& e) {
86520       {
86521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86522       };
86523     } catch (std::exception& e) {
86524       {
86525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86526       };
86527     } catch (Dali::DaliException e) {
86528       {
86529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86530       };
86531     } catch (...) {
86532       {
86533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86534       };
86535     }
86536   }
86537
86538   jresult = (void *)result;
86539   return jresult;
86540 }
86541
86542
86543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86544   void * jresult ;
86545   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86546   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86547
86548   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86549   {
86550     try {
86551       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86552     } catch (std::out_of_range& e) {
86553       {
86554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86555       };
86556     } catch (std::exception& e) {
86557       {
86558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86559       };
86560     } catch (Dali::DaliException e) {
86561       {
86562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86563       };
86564     } catch (...) {
86565       {
86566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86567       };
86568     }
86569   }
86570
86571   jresult = (void *)result;
86572   return jresult;
86573 }
86574
86575
86576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86577   void * jresult ;
86578   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86579   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86580
86581   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86582   {
86583     try {
86584       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86585     } catch (std::out_of_range& e) {
86586       {
86587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86588       };
86589     } catch (std::exception& e) {
86590       {
86591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86592       };
86593     } catch (Dali::DaliException e) {
86594       {
86595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86596       };
86597     } catch (...) {
86598       {
86599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86600       };
86601     }
86602   }
86603
86604   jresult = (void *)result;
86605   return jresult;
86606 }
86607
86608
86609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86610   void * jresult ;
86611   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86612   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86613
86614   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86615   {
86616     try {
86617       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86618     } catch (std::out_of_range& e) {
86619       {
86620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86621       };
86622     } catch (std::exception& e) {
86623       {
86624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86625       };
86626     } catch (Dali::DaliException e) {
86627       {
86628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86629       };
86630     } catch (...) {
86631       {
86632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86633       };
86634     }
86635   }
86636
86637   jresult = (void *)result;
86638   return jresult;
86639 }
86640
86641
86642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86643   void * jresult ;
86644   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86645   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86646
86647   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86648   {
86649     try {
86650       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86651     } catch (std::out_of_range& e) {
86652       {
86653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86654       };
86655     } catch (std::exception& e) {
86656       {
86657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86658       };
86659     } catch (Dali::DaliException e) {
86660       {
86661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86662       };
86663     } catch (...) {
86664       {
86665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86666       };
86667     }
86668   }
86669
86670   jresult = (void *)result;
86671   return jresult;
86672 }
86673
86674
86675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86676   void * jresult ;
86677   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86678   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86679
86680   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86681   {
86682     try {
86683       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86684     } catch (std::out_of_range& e) {
86685       {
86686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86687       };
86688     } catch (std::exception& e) {
86689       {
86690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86691       };
86692     } catch (Dali::DaliException e) {
86693       {
86694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86695       };
86696     } catch (...) {
86697       {
86698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86699       };
86700     }
86701   }
86702
86703   jresult = (void *)result;
86704   return jresult;
86705 }
86706
86707
86708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86709   void * jresult ;
86710   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86711   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86712
86713   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86714   {
86715     try {
86716       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86717     } catch (std::out_of_range& e) {
86718       {
86719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86720       };
86721     } catch (std::exception& e) {
86722       {
86723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86724       };
86725     } catch (Dali::DaliException e) {
86726       {
86727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86728       };
86729     } catch (...) {
86730       {
86731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86732       };
86733     }
86734   }
86735
86736   jresult = (void *)result;
86737   return jresult;
86738 }
86739
86740
86741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86742   void * jresult ;
86743   Dali::Toolkit::StyleManager *result = 0 ;
86744
86745   {
86746     try {
86747       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86748     } catch (std::out_of_range& e) {
86749       {
86750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86751       };
86752     } catch (std::exception& e) {
86753       {
86754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86755       };
86756     } catch (Dali::DaliException e) {
86757       {
86758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86759       };
86760     } catch (...) {
86761       {
86762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86763       };
86764     }
86765   }
86766
86767   jresult = (void *)result;
86768   return jresult;
86769 }
86770
86771
86772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86773   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86774
86775   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86776   {
86777     try {
86778       delete arg1;
86779     } catch (std::out_of_range& e) {
86780       {
86781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86782       };
86783     } catch (std::exception& e) {
86784       {
86785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86786       };
86787     } catch (Dali::DaliException e) {
86788       {
86789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86790       };
86791     } catch (...) {
86792       {
86793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86794       };
86795     }
86796   }
86797
86798 }
86799
86800
86801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86802   void * jresult ;
86803   Dali::Toolkit::StyleManager result;
86804
86805   {
86806     try {
86807       result = Dali::Toolkit::StyleManager::Get();
86808     } catch (std::out_of_range& e) {
86809       {
86810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86811       };
86812     } catch (std::exception& e) {
86813       {
86814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86815       };
86816     } catch (Dali::DaliException e) {
86817       {
86818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86819       };
86820     } catch (...) {
86821       {
86822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86823       };
86824     }
86825   }
86826
86827   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86828   return jresult;
86829 }
86830
86831
86832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86833   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86834   std::string *arg2 = 0 ;
86835
86836   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86837   if (!jarg2) {
86838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86839     return ;
86840   }
86841   std::string arg2_str(jarg2);
86842   arg2 = &arg2_str;
86843   {
86844     try {
86845       (arg1)->ApplyTheme((std::string const &)*arg2);
86846     } catch (std::out_of_range& e) {
86847       {
86848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86849       };
86850     } catch (std::exception& e) {
86851       {
86852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86853       };
86854     } catch (Dali::DaliException e) {
86855       {
86856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86857       };
86858     } catch (...) {
86859       {
86860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86861       };
86862     }
86863   }
86864
86865
86866   //argout typemap for const std::string&
86867
86868 }
86869
86870
86871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86872   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86873
86874   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86875   {
86876     try {
86877       (arg1)->ApplyDefaultTheme();
86878     } catch (std::out_of_range& e) {
86879       {
86880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86881       };
86882     } catch (std::exception& e) {
86883       {
86884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86885       };
86886     } catch (Dali::DaliException e) {
86887       {
86888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86889       };
86890     } catch (...) {
86891       {
86892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86893       };
86894     }
86895   }
86896
86897 }
86898
86899
86900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86901   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86902   std::string *arg2 = 0 ;
86903   Dali::Property::Value *arg3 = 0 ;
86904
86905   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86906   if (!jarg2) {
86907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86908     return ;
86909   }
86910   std::string arg2_str(jarg2);
86911   arg2 = &arg2_str;
86912   arg3 = (Dali::Property::Value *)jarg3;
86913   if (!arg3) {
86914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86915     return ;
86916   }
86917   {
86918     try {
86919       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86920     } catch (std::out_of_range& e) {
86921       {
86922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86923       };
86924     } catch (std::exception& e) {
86925       {
86926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86927       };
86928     } catch (Dali::DaliException e) {
86929       {
86930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86931       };
86932     } catch (...) {
86933       {
86934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86935       };
86936     }
86937   }
86938
86939
86940   //argout typemap for const std::string&
86941
86942 }
86943
86944
86945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86946   unsigned int jresult ;
86947   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86948   std::string *arg2 = 0 ;
86949   Dali::Property::Value *arg3 = 0 ;
86950   bool result;
86951
86952   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86953   if (!jarg2) {
86954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86955     return 0;
86956   }
86957   std::string arg2_str(jarg2);
86958   arg2 = &arg2_str;
86959   arg3 = (Dali::Property::Value *)jarg3;
86960   if (!arg3) {
86961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86962     return 0;
86963   }
86964   {
86965     try {
86966       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86967     } catch (std::out_of_range& e) {
86968       {
86969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86970       };
86971     } catch (std::exception& e) {
86972       {
86973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86974       };
86975     } catch (Dali::DaliException e) {
86976       {
86977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86978       };
86979     } catch (...) {
86980       {
86981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86982       };
86983     }
86984   }
86985
86986   jresult = result;
86987
86988   //argout typemap for const std::string&
86989
86990   return jresult;
86991 }
86992
86993
86994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86995   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86996   Dali::Toolkit::Control arg2 ;
86997   std::string *arg3 = 0 ;
86998   std::string *arg4 = 0 ;
86999   Dali::Toolkit::Control *argp2 ;
87000
87001   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87002   argp2 = (Dali::Toolkit::Control *)jarg2;
87003   if (!argp2) {
87004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87005     return ;
87006   }
87007   arg2 = *argp2;
87008   if (!jarg3) {
87009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87010     return ;
87011   }
87012   std::string arg3_str(jarg3);
87013   arg3 = &arg3_str;
87014   if (!jarg4) {
87015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87016     return ;
87017   }
87018   std::string arg4_str(jarg4);
87019   arg4 = &arg4_str;
87020   {
87021     try {
87022       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
87023     } catch (std::out_of_range& e) {
87024       {
87025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87026       };
87027     } catch (std::exception& e) {
87028       {
87029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87030       };
87031     } catch (Dali::DaliException e) {
87032       {
87033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87034       };
87035     } catch (...) {
87036       {
87037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87038       };
87039     }
87040   }
87041
87042
87043   //argout typemap for const std::string&
87044
87045
87046   //argout typemap for const std::string&
87047
87048 }
87049
87050
87051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
87052   void * jresult ;
87053   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87054   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
87055
87056   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87057   {
87058     try {
87059       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
87060     } catch (std::out_of_range& e) {
87061       {
87062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87063       };
87064     } catch (std::exception& e) {
87065       {
87066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87067       };
87068     } catch (Dali::DaliException e) {
87069       {
87070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87071       };
87072     } catch (...) {
87073       {
87074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87075       };
87076     }
87077   }
87078
87079   jresult = (void *)result;
87080   return jresult;
87081 }
87082
87083
87084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87085   int jresult ;
87086   int result;
87087
87088   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87089   jresult = (int)result;
87090   return jresult;
87091 }
87092
87093
87094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87095   int jresult ;
87096   int result;
87097
87098   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87099   jresult = (int)result;
87100   return jresult;
87101 }
87102
87103
87104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87105   int jresult ;
87106   int result;
87107
87108   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87109   jresult = (int)result;
87110   return jresult;
87111 }
87112
87113
87114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87115   int jresult ;
87116   int result;
87117
87118   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87119   jresult = (int)result;
87120   return jresult;
87121 }
87122
87123
87124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87125   int jresult ;
87126   int result;
87127
87128   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87129   jresult = (int)result;
87130   return jresult;
87131 }
87132
87133
87134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87135   int jresult ;
87136   int result;
87137
87138   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87139   jresult = (int)result;
87140   return jresult;
87141 }
87142
87143
87144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87145   int jresult ;
87146   int result;
87147
87148   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87149   jresult = (int)result;
87150   return jresult;
87151 }
87152
87153
87154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87155   int jresult ;
87156   int result;
87157
87158   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87159   jresult = (int)result;
87160   return jresult;
87161 }
87162
87163
87164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87165   int jresult ;
87166   int result;
87167
87168   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87169   jresult = (int)result;
87170   return jresult;
87171 }
87172
87173
87174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87175   int jresult ;
87176   int result;
87177
87178   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87179   jresult = (int)result;
87180   return jresult;
87181 }
87182
87183
87184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87185   int jresult ;
87186   int result;
87187
87188   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87189   jresult = (int)result;
87190   return jresult;
87191 }
87192
87193
87194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87195   int jresult ;
87196   int result;
87197
87198   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87199   jresult = (int)result;
87200   return jresult;
87201 }
87202
87203
87204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87205   int jresult ;
87206   int result;
87207
87208   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87209   jresult = (int)result;
87210   return jresult;
87211 }
87212
87213
87214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87215   int jresult ;
87216   int result;
87217
87218   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87219   jresult = (int)result;
87220   return jresult;
87221 }
87222
87223
87224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87225   int jresult ;
87226   int result;
87227
87228   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87229   jresult = (int)result;
87230   return jresult;
87231 }
87232
87233
87234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87235   void * jresult ;
87236   Dali::Toolkit::Slider::Property *result = 0 ;
87237
87238   {
87239     try {
87240       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87241     } catch (std::out_of_range& e) {
87242       {
87243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87244       };
87245     } catch (std::exception& e) {
87246       {
87247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87248       };
87249     } catch (Dali::DaliException e) {
87250       {
87251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87252       };
87253     } catch (...) {
87254       {
87255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87256       };
87257     }
87258   }
87259
87260   jresult = (void *)result;
87261   return jresult;
87262 }
87263
87264
87265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87266   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87267
87268   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87269   {
87270     try {
87271       delete arg1;
87272     } catch (std::out_of_range& e) {
87273       {
87274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87275       };
87276     } catch (std::exception& e) {
87277       {
87278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87279       };
87280     } catch (Dali::DaliException e) {
87281       {
87282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87283       };
87284     } catch (...) {
87285       {
87286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87287       };
87288     }
87289   }
87290
87291 }
87292
87293
87294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87295   void * jresult ;
87296   Dali::Toolkit::Slider result;
87297
87298   {
87299     try {
87300       result = Dali::Toolkit::Slider::New();
87301     } catch (std::out_of_range& e) {
87302       {
87303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87304       };
87305     } catch (std::exception& e) {
87306       {
87307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87308       };
87309     } catch (Dali::DaliException e) {
87310       {
87311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87312       };
87313     } catch (...) {
87314       {
87315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87316       };
87317     }
87318   }
87319
87320   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87321   return jresult;
87322 }
87323
87324
87325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87326   void * jresult ;
87327   Dali::Toolkit::Slider *result = 0 ;
87328
87329   {
87330     try {
87331       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87332     } catch (std::out_of_range& e) {
87333       {
87334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87335       };
87336     } catch (std::exception& e) {
87337       {
87338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87339       };
87340     } catch (Dali::DaliException e) {
87341       {
87342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87343       };
87344     } catch (...) {
87345       {
87346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87347       };
87348     }
87349   }
87350
87351   jresult = (void *)result;
87352   return jresult;
87353 }
87354
87355
87356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87357   void * jresult ;
87358   Dali::Toolkit::Slider *arg1 = 0 ;
87359   Dali::Toolkit::Slider *result = 0 ;
87360
87361   arg1 = (Dali::Toolkit::Slider *)jarg1;
87362   if (!arg1) {
87363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87364     return 0;
87365   }
87366   {
87367     try {
87368       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87369     } catch (std::out_of_range& e) {
87370       {
87371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87372       };
87373     } catch (std::exception& e) {
87374       {
87375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87376       };
87377     } catch (Dali::DaliException e) {
87378       {
87379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87380       };
87381     } catch (...) {
87382       {
87383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87384       };
87385     }
87386   }
87387
87388   jresult = (void *)result;
87389   return jresult;
87390 }
87391
87392
87393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87394   void * jresult ;
87395   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87396   Dali::Toolkit::Slider *arg2 = 0 ;
87397   Dali::Toolkit::Slider *result = 0 ;
87398
87399   arg1 = (Dali::Toolkit::Slider *)jarg1;
87400   arg2 = (Dali::Toolkit::Slider *)jarg2;
87401   if (!arg2) {
87402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87403     return 0;
87404   }
87405   {
87406     try {
87407       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87408     } catch (std::out_of_range& e) {
87409       {
87410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87411       };
87412     } catch (std::exception& e) {
87413       {
87414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87415       };
87416     } catch (Dali::DaliException e) {
87417       {
87418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87419       };
87420     } catch (...) {
87421       {
87422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87423       };
87424     }
87425   }
87426
87427   jresult = (void *)result;
87428   return jresult;
87429 }
87430
87431
87432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87433   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87434
87435   arg1 = (Dali::Toolkit::Slider *)jarg1;
87436   {
87437     try {
87438       delete arg1;
87439     } catch (std::out_of_range& e) {
87440       {
87441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87442       };
87443     } catch (std::exception& e) {
87444       {
87445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87446       };
87447     } catch (Dali::DaliException e) {
87448       {
87449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87450       };
87451     } catch (...) {
87452       {
87453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87454       };
87455     }
87456   }
87457
87458 }
87459
87460
87461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87462   void * jresult ;
87463   Dali::BaseHandle arg1 ;
87464   Dali::BaseHandle *argp1 ;
87465   Dali::Toolkit::Slider result;
87466
87467   argp1 = (Dali::BaseHandle *)jarg1;
87468   if (!argp1) {
87469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87470     return 0;
87471   }
87472   arg1 = *argp1;
87473   {
87474     try {
87475       result = Dali::Toolkit::Slider::DownCast(arg1);
87476     } catch (std::out_of_range& e) {
87477       {
87478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87479       };
87480     } catch (std::exception& e) {
87481       {
87482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87483       };
87484     } catch (Dali::DaliException e) {
87485       {
87486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87487       };
87488     } catch (...) {
87489       {
87490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87491       };
87492     }
87493   }
87494
87495   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87496   return jresult;
87497 }
87498
87499
87500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87501   void * jresult ;
87502   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87503   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87504
87505   arg1 = (Dali::Toolkit::Slider *)jarg1;
87506   {
87507     try {
87508       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87509     } catch (std::out_of_range& e) {
87510       {
87511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87512       };
87513     } catch (std::exception& e) {
87514       {
87515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87516       };
87517     } catch (Dali::DaliException e) {
87518       {
87519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87520       };
87521     } catch (...) {
87522       {
87523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87524       };
87525     }
87526   }
87527
87528   jresult = (void *)result;
87529   return jresult;
87530 }
87531
87532
87533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87534   void * jresult ;
87535   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87536   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87537
87538   arg1 = (Dali::Toolkit::Slider *)jarg1;
87539   {
87540     try {
87541       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87542     } catch (std::out_of_range& e) {
87543       {
87544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87545       };
87546     } catch (std::exception& e) {
87547       {
87548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87549       };
87550     } catch (Dali::DaliException e) {
87551       {
87552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87553       };
87554     } catch (...) {
87555       {
87556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87557       };
87558     }
87559   }
87560
87561   jresult = (void *)result;
87562   return jresult;
87563 }
87564
87565
87566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87567   void * jresult ;
87568   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87569   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87570
87571   arg1 = (Dali::Toolkit::Slider *)jarg1;
87572   {
87573     try {
87574       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87575     } catch (std::out_of_range& e) {
87576       {
87577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87578       };
87579     } catch (std::exception& e) {
87580       {
87581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87582       };
87583     } catch (Dali::DaliException e) {
87584       {
87585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87586       };
87587     } catch (...) {
87588       {
87589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87590       };
87591     }
87592   }
87593
87594   jresult = (void *)result;
87595   return jresult;
87596 }
87597
87598
87599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87600   int jresult ;
87601   int result;
87602
87603   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87604   jresult = (int)result;
87605   return jresult;
87606 }
87607
87608
87609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87610   int jresult ;
87611   int result;
87612
87613   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87614   jresult = (int)result;
87615   return jresult;
87616 }
87617
87618
87619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87620   int jresult ;
87621   int result;
87622
87623   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87624   jresult = (int)result;
87625   return jresult;
87626 }
87627
87628
87629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87630   int jresult ;
87631   int result;
87632
87633   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87634   jresult = (int)result;
87635   return jresult;
87636 }
87637
87638
87639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87640   int result;
87641
87642   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87643
87644   return result;
87645 }
87646
87647
87648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87649   void * jresult ;
87650   Dali::Toolkit::VideoView::Property *result = 0 ;
87651
87652   {
87653     try {
87654       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87655     } catch (std::out_of_range& e) {
87656       {
87657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87658       };
87659     } catch (std::exception& e) {
87660       {
87661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87662       };
87663     } catch (Dali::DaliException e) {
87664       {
87665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87666       };
87667     } catch (...) {
87668       {
87669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87670       };
87671     }
87672   }
87673
87674   jresult = (void *)result;
87675   return jresult;
87676 }
87677
87678
87679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87680   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87681
87682   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87683   {
87684     try {
87685       delete arg1;
87686     } catch (std::out_of_range& e) {
87687       {
87688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87689       };
87690     } catch (std::exception& e) {
87691       {
87692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87693       };
87694     } catch (Dali::DaliException e) {
87695       {
87696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87697       };
87698     } catch (...) {
87699       {
87700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87701       };
87702     }
87703   }
87704
87705 }
87706
87707
87708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87709   void * jresult ;
87710   Dali::Toolkit::VideoView result;
87711
87712   {
87713     try {
87714       result = Dali::Toolkit::VideoView::New();
87715     } catch (std::out_of_range& e) {
87716       {
87717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87718       };
87719     } catch (std::exception& e) {
87720       {
87721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87722       };
87723     } catch (Dali::DaliException e) {
87724       {
87725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87726       };
87727     } catch (...) {
87728       {
87729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87730       };
87731     }
87732   }
87733
87734   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87735   return jresult;
87736 }
87737
87738
87739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87740   void * jresult ;
87741   std::string *arg1 = 0 ;
87742   Dali::Toolkit::VideoView result;
87743
87744   if (!jarg1) {
87745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87746     return 0;
87747   }
87748   std::string arg1_str(jarg1);
87749   arg1 = &arg1_str;
87750   {
87751     try {
87752       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87753     } catch (std::out_of_range& e) {
87754       {
87755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87756       };
87757     } catch (std::exception& e) {
87758       {
87759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87760       };
87761     } catch (Dali::DaliException e) {
87762       {
87763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87764       };
87765     } catch (...) {
87766       {
87767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87768       };
87769     }
87770   }
87771
87772   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87773
87774   //argout typemap for const std::string&
87775
87776   return jresult;
87777 }
87778
87779
87780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87781   void * jresult ;
87782   Dali::Toolkit::VideoView *result = 0 ;
87783
87784   {
87785     try {
87786       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87787     } catch (std::out_of_range& e) {
87788       {
87789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87790       };
87791     } catch (std::exception& e) {
87792       {
87793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87794       };
87795     } catch (Dali::DaliException e) {
87796       {
87797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87798       };
87799     } catch (...) {
87800       {
87801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87802       };
87803     }
87804   }
87805
87806   jresult = (void *)result;
87807   return jresult;
87808 }
87809
87810
87811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87812   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87813
87814   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87815   {
87816     try {
87817       delete arg1;
87818     } catch (std::out_of_range& e) {
87819       {
87820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87821       };
87822     } catch (std::exception& e) {
87823       {
87824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87825       };
87826     } catch (Dali::DaliException e) {
87827       {
87828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87829       };
87830     } catch (...) {
87831       {
87832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87833       };
87834     }
87835   }
87836
87837 }
87838
87839
87840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87841   void * jresult ;
87842   Dali::Toolkit::VideoView *arg1 = 0 ;
87843   Dali::Toolkit::VideoView *result = 0 ;
87844
87845   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87846   if (!arg1) {
87847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87848     return 0;
87849   }
87850   {
87851     try {
87852       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87853     } catch (std::out_of_range& e) {
87854       {
87855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87856       };
87857     } catch (std::exception& e) {
87858       {
87859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87860       };
87861     } catch (Dali::DaliException e) {
87862       {
87863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87864       };
87865     } catch (...) {
87866       {
87867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87868       };
87869     }
87870   }
87871
87872   jresult = (void *)result;
87873   return jresult;
87874 }
87875
87876
87877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87878   void * jresult ;
87879   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87880   Dali::Toolkit::VideoView *arg2 = 0 ;
87881   Dali::Toolkit::VideoView *result = 0 ;
87882
87883   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87884   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87885   if (!arg2) {
87886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87887     return 0;
87888   }
87889   {
87890     try {
87891       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87892     } catch (std::out_of_range& e) {
87893       {
87894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87895       };
87896     } catch (std::exception& e) {
87897       {
87898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87899       };
87900     } catch (Dali::DaliException e) {
87901       {
87902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87903       };
87904     } catch (...) {
87905       {
87906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87907       };
87908     }
87909   }
87910
87911   jresult = (void *)result;
87912   return jresult;
87913 }
87914
87915
87916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87917   void * jresult ;
87918   Dali::BaseHandle arg1 ;
87919   Dali::BaseHandle *argp1 ;
87920   Dali::Toolkit::VideoView result;
87921
87922   argp1 = (Dali::BaseHandle *)jarg1;
87923   if (!argp1) {
87924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87925     return 0;
87926   }
87927   arg1 = *argp1;
87928   {
87929     try {
87930       result = Dali::Toolkit::VideoView::DownCast(arg1);
87931     } catch (std::out_of_range& e) {
87932       {
87933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87934       };
87935     } catch (std::exception& e) {
87936       {
87937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87938       };
87939     } catch (Dali::DaliException e) {
87940       {
87941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87942       };
87943     } catch (...) {
87944       {
87945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87946       };
87947     }
87948   }
87949
87950   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87951   return jresult;
87952 }
87953
87954
87955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87956   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87957
87958   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87959   {
87960     try {
87961       (arg1)->Play();
87962     } catch (std::out_of_range& e) {
87963       {
87964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87965       };
87966     } catch (std::exception& e) {
87967       {
87968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87969       };
87970     } catch (Dali::DaliException e) {
87971       {
87972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87973       };
87974     } catch (...) {
87975       {
87976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87977       };
87978     }
87979   }
87980
87981 }
87982
87983
87984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87985   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87986
87987   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87988   {
87989     try {
87990       (arg1)->Pause();
87991     } catch (std::out_of_range& e) {
87992       {
87993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87994       };
87995     } catch (std::exception& e) {
87996       {
87997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87998       };
87999     } catch (Dali::DaliException e) {
88000       {
88001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88002       };
88003     } catch (...) {
88004       {
88005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88006       };
88007     }
88008   }
88009
88010 }
88011
88012
88013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
88014   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88015
88016   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88017   {
88018     try {
88019       (arg1)->Stop();
88020     } catch (std::out_of_range& e) {
88021       {
88022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88023       };
88024     } catch (std::exception& e) {
88025       {
88026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88027       };
88028     } catch (Dali::DaliException e) {
88029       {
88030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88031       };
88032     } catch (...) {
88033       {
88034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88035       };
88036     }
88037   }
88038
88039 }
88040
88041
88042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
88043   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88044   int arg2 ;
88045
88046   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88047   arg2 = (int)jarg2;
88048   {
88049     try {
88050       (arg1)->Forward(arg2);
88051     } catch (std::out_of_range& e) {
88052       {
88053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88054       };
88055     } catch (std::exception& e) {
88056       {
88057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88058       };
88059     } catch (Dali::DaliException e) {
88060       {
88061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88062       };
88063     } catch (...) {
88064       {
88065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88066       };
88067     }
88068   }
88069
88070 }
88071
88072
88073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88074   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88075   int arg2 ;
88076
88077   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88078   arg2 = (int)jarg2;
88079   {
88080     try {
88081       (arg1)->Backward(arg2);
88082     } catch (std::out_of_range& e) {
88083       {
88084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88085       };
88086     } catch (std::exception& e) {
88087       {
88088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88089       };
88090     } catch (Dali::DaliException e) {
88091       {
88092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88093       };
88094     } catch (...) {
88095       {
88096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88097       };
88098     }
88099   }
88100
88101 }
88102
88103
88104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88105   void * jresult ;
88106   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88107   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88108
88109   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88110   {
88111     try {
88112       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88113     } catch (std::out_of_range& e) {
88114       {
88115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88116       };
88117     } catch (std::exception& e) {
88118       {
88119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88120       };
88121     } catch (Dali::DaliException e) {
88122       {
88123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88124       };
88125     } catch (...) {
88126       {
88127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88128       };
88129     }
88130   }
88131
88132   jresult = (void *)result;
88133   return jresult;
88134 }
88135
88136
88137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88138   int jresult ;
88139   int result;
88140
88141   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88142   jresult = (int)result;
88143   return jresult;
88144 }
88145
88146
88147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88148   int jresult ;
88149   int result;
88150
88151   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88152   jresult = (int)result;
88153   return jresult;
88154 }
88155
88156
88157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88158   int jresult ;
88159   int result;
88160
88161   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88162   jresult = (int)result;
88163   return jresult;
88164 }
88165
88166
88167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88168   int jresult ;
88169   int result;
88170
88171   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88172   jresult = (int)result;
88173   return jresult;
88174 }
88175
88176
88177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88178   int jresult ;
88179   int result;
88180
88181   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88182   jresult = (int)result;
88183   return jresult;
88184 }
88185
88186
88187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88188   int jresult ;
88189   int result;
88190
88191   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88192   jresult = (int)result;
88193   return jresult;
88194 }
88195
88196
88197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88198   int jresult ;
88199   int result;
88200
88201   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88202   jresult = (int)result;
88203   return jresult;
88204 }
88205
88206
88207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88208   int jresult ;
88209   int result;
88210
88211   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88212   jresult = (int)result;
88213   return jresult;
88214 }
88215
88216
88217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88218   int jresult ;
88219   int result;
88220
88221   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88222   jresult = (int)result;
88223   return jresult;
88224 }
88225
88226
88227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88228   int jresult ;
88229   int result;
88230
88231   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88232   jresult = (int)result;
88233   return jresult;
88234 }
88235
88236
88237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88238   int jresult ;
88239   int result;
88240
88241   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88242   jresult = (int)result;
88243   return jresult;
88244 }
88245
88246
88247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88248   int jresult ;
88249   int result;
88250
88251   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88252   jresult = (int)result;
88253   return jresult;
88254 }
88255
88256
88257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88258   int jresult ;
88259   int result;
88260
88261   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88262   jresult = (int)result;
88263   return jresult;
88264 }
88265
88266
88267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88268   int jresult ;
88269   int result;
88270
88271   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88272   jresult = (int)result;
88273   return jresult;
88274 }
88275
88276
88277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88278   int jresult ;
88279   int result;
88280
88281   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88282   jresult = (int)result;
88283   return jresult;
88284 }
88285
88286
88287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88288   int jresult ;
88289   int result;
88290
88291   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88292   jresult = (int)result;
88293   return jresult;
88294 }
88295
88296
88297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88298   int jresult ;
88299   int result;
88300
88301   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88302   jresult = (int)result;
88303   return jresult;
88304 }
88305
88306
88307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88308   int jresult ;
88309   int result;
88310
88311   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88312   jresult = (int)result;
88313   return jresult;
88314 }
88315
88316
88317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88318   int jresult ;
88319   int result;
88320
88321   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88322   jresult = (int)result;
88323   return jresult;
88324 }
88325
88326
88327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88328   int jresult ;
88329   int result;
88330
88331   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88332   jresult = (int)result;
88333   return jresult;
88334 }
88335
88336
88337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88338   int jresult ;
88339   int result;
88340
88341   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88342   jresult = (int)result;
88343   return jresult;
88344 }
88345
88346
88347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88348   void * jresult ;
88349   Dali::Toolkit::Popup::Property *result = 0 ;
88350
88351   {
88352     try {
88353       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88354     } catch (std::out_of_range& e) {
88355       {
88356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88357       };
88358     } catch (std::exception& e) {
88359       {
88360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88361       };
88362     } catch (Dali::DaliException e) {
88363       {
88364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88365       };
88366     } catch (...) {
88367       {
88368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88369       };
88370     }
88371   }
88372
88373   jresult = (void *)result;
88374   return jresult;
88375 }
88376
88377
88378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88379   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88380
88381   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88382   {
88383     try {
88384       delete arg1;
88385     } catch (std::out_of_range& e) {
88386       {
88387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88388       };
88389     } catch (std::exception& e) {
88390       {
88391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88392       };
88393     } catch (Dali::DaliException e) {
88394       {
88395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88396       };
88397     } catch (...) {
88398       {
88399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88400       };
88401     }
88402   }
88403
88404 }
88405
88406
88407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88408   void * jresult ;
88409   Dali::Toolkit::Popup *result = 0 ;
88410
88411   {
88412     try {
88413       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88414     } catch (std::out_of_range& e) {
88415       {
88416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88417       };
88418     } catch (std::exception& e) {
88419       {
88420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88421       };
88422     } catch (Dali::DaliException e) {
88423       {
88424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88425       };
88426     } catch (...) {
88427       {
88428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88429       };
88430     }
88431   }
88432
88433   jresult = (void *)result;
88434   return jresult;
88435 }
88436
88437
88438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88439   void * jresult ;
88440   Dali::Toolkit::Popup result;
88441
88442   {
88443     try {
88444       result = Dali::Toolkit::Popup::New();
88445     } catch (std::out_of_range& e) {
88446       {
88447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88448       };
88449     } catch (std::exception& e) {
88450       {
88451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88452       };
88453     } catch (Dali::DaliException e) {
88454       {
88455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88456       };
88457     } catch (...) {
88458       {
88459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88460       };
88461     }
88462   }
88463
88464   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88465   return jresult;
88466 }
88467
88468
88469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88470   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88471
88472   arg1 = (Dali::Toolkit::Popup *)jarg1;
88473   {
88474     try {
88475       delete arg1;
88476     } catch (std::out_of_range& e) {
88477       {
88478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88479       };
88480     } catch (std::exception& e) {
88481       {
88482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88483       };
88484     } catch (Dali::DaliException e) {
88485       {
88486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88487       };
88488     } catch (...) {
88489       {
88490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88491       };
88492     }
88493   }
88494
88495 }
88496
88497
88498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88499   void * jresult ;
88500   Dali::Toolkit::Popup *arg1 = 0 ;
88501   Dali::Toolkit::Popup *result = 0 ;
88502
88503   arg1 = (Dali::Toolkit::Popup *)jarg1;
88504   if (!arg1) {
88505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88506     return 0;
88507   }
88508   {
88509     try {
88510       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88511     } catch (std::out_of_range& e) {
88512       {
88513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88514       };
88515     } catch (std::exception& e) {
88516       {
88517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88518       };
88519     } catch (Dali::DaliException e) {
88520       {
88521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88522       };
88523     } catch (...) {
88524       {
88525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88526       };
88527     }
88528   }
88529
88530   jresult = (void *)result;
88531   return jresult;
88532 }
88533
88534
88535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88536   void * jresult ;
88537   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88538   Dali::Toolkit::Popup *arg2 = 0 ;
88539   Dali::Toolkit::Popup *result = 0 ;
88540
88541   arg1 = (Dali::Toolkit::Popup *)jarg1;
88542   arg2 = (Dali::Toolkit::Popup *)jarg2;
88543   if (!arg2) {
88544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88545     return 0;
88546   }
88547   {
88548     try {
88549       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88550     } catch (std::out_of_range& e) {
88551       {
88552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88553       };
88554     } catch (std::exception& e) {
88555       {
88556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88557       };
88558     } catch (Dali::DaliException e) {
88559       {
88560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88561       };
88562     } catch (...) {
88563       {
88564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88565       };
88566     }
88567   }
88568
88569   jresult = (void *)result;
88570   return jresult;
88571 }
88572
88573
88574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88575   void * jresult ;
88576   Dali::BaseHandle arg1 ;
88577   Dali::BaseHandle *argp1 ;
88578   Dali::Toolkit::Popup result;
88579
88580   argp1 = (Dali::BaseHandle *)jarg1;
88581   if (!argp1) {
88582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88583     return 0;
88584   }
88585   arg1 = *argp1;
88586   {
88587     try {
88588       result = Dali::Toolkit::Popup::DownCast(arg1);
88589     } catch (std::out_of_range& e) {
88590       {
88591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88592       };
88593     } catch (std::exception& e) {
88594       {
88595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88596       };
88597     } catch (Dali::DaliException e) {
88598       {
88599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88600       };
88601     } catch (...) {
88602       {
88603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88604       };
88605     }
88606   }
88607
88608   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88609   return jresult;
88610 }
88611
88612
88613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88614   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88615   Dali::Actor arg2 ;
88616   Dali::Actor *argp2 ;
88617
88618   arg1 = (Dali::Toolkit::Popup *)jarg1;
88619   argp2 = (Dali::Actor *)jarg2;
88620   if (!argp2) {
88621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88622     return ;
88623   }
88624   arg2 = *argp2;
88625   {
88626     try {
88627       (arg1)->SetTitle(arg2);
88628     } catch (std::out_of_range& e) {
88629       {
88630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88631       };
88632     } catch (std::exception& e) {
88633       {
88634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88635       };
88636     } catch (Dali::DaliException e) {
88637       {
88638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88639       };
88640     } catch (...) {
88641       {
88642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88643       };
88644     }
88645   }
88646
88647 }
88648
88649
88650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88651   void * jresult ;
88652   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88653   Dali::Actor result;
88654
88655   arg1 = (Dali::Toolkit::Popup *)jarg1;
88656   {
88657     try {
88658       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88659     } catch (std::out_of_range& e) {
88660       {
88661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88662       };
88663     } catch (std::exception& e) {
88664       {
88665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88666       };
88667     } catch (Dali::DaliException e) {
88668       {
88669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88670       };
88671     } catch (...) {
88672       {
88673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88674       };
88675     }
88676   }
88677
88678   jresult = new Dali::Actor((const Dali::Actor &)result);
88679   return jresult;
88680 }
88681
88682
88683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88684   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88685   Dali::Actor arg2 ;
88686   Dali::Actor *argp2 ;
88687
88688   arg1 = (Dali::Toolkit::Popup *)jarg1;
88689   argp2 = (Dali::Actor *)jarg2;
88690   if (!argp2) {
88691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88692     return ;
88693   }
88694   arg2 = *argp2;
88695   {
88696     try {
88697       (arg1)->SetContent(arg2);
88698     } catch (std::out_of_range& e) {
88699       {
88700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88701       };
88702     } catch (std::exception& e) {
88703       {
88704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88705       };
88706     } catch (Dali::DaliException e) {
88707       {
88708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88709       };
88710     } catch (...) {
88711       {
88712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88713       };
88714     }
88715   }
88716
88717 }
88718
88719
88720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88721   void * jresult ;
88722   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88723   Dali::Actor result;
88724
88725   arg1 = (Dali::Toolkit::Popup *)jarg1;
88726   {
88727     try {
88728       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88729     } catch (std::out_of_range& e) {
88730       {
88731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88732       };
88733     } catch (std::exception& e) {
88734       {
88735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88736       };
88737     } catch (Dali::DaliException e) {
88738       {
88739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88740       };
88741     } catch (...) {
88742       {
88743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88744       };
88745     }
88746   }
88747
88748   jresult = new Dali::Actor((const Dali::Actor &)result);
88749   return jresult;
88750 }
88751
88752
88753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88754   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88755   Dali::Actor arg2 ;
88756   Dali::Actor *argp2 ;
88757
88758   arg1 = (Dali::Toolkit::Popup *)jarg1;
88759   argp2 = (Dali::Actor *)jarg2;
88760   if (!argp2) {
88761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88762     return ;
88763   }
88764   arg2 = *argp2;
88765   {
88766     try {
88767       (arg1)->SetFooter(arg2);
88768     } catch (std::out_of_range& e) {
88769       {
88770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88771       };
88772     } catch (std::exception& e) {
88773       {
88774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88775       };
88776     } catch (Dali::DaliException e) {
88777       {
88778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88779       };
88780     } catch (...) {
88781       {
88782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88783       };
88784     }
88785   }
88786
88787 }
88788
88789
88790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88791   void * jresult ;
88792   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88793   Dali::Actor result;
88794
88795   arg1 = (Dali::Toolkit::Popup *)jarg1;
88796   {
88797     try {
88798       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88799     } catch (std::out_of_range& e) {
88800       {
88801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88802       };
88803     } catch (std::exception& e) {
88804       {
88805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88806       };
88807     } catch (Dali::DaliException e) {
88808       {
88809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88810       };
88811     } catch (...) {
88812       {
88813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88814       };
88815     }
88816   }
88817
88818   jresult = new Dali::Actor((const Dali::Actor &)result);
88819   return jresult;
88820 }
88821
88822
88823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88824   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88825   Dali::Toolkit::Popup::DisplayState arg2 ;
88826
88827   arg1 = (Dali::Toolkit::Popup *)jarg1;
88828   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88829   {
88830     try {
88831       (arg1)->SetDisplayState(arg2);
88832     } catch (std::out_of_range& e) {
88833       {
88834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88835       };
88836     } catch (std::exception& e) {
88837       {
88838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88839       };
88840     } catch (Dali::DaliException e) {
88841       {
88842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88843       };
88844     } catch (...) {
88845       {
88846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88847       };
88848     }
88849   }
88850
88851 }
88852
88853
88854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88855   int jresult ;
88856   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88857   Dali::Toolkit::Popup::DisplayState result;
88858
88859   arg1 = (Dali::Toolkit::Popup *)jarg1;
88860   {
88861     try {
88862       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88863     } catch (std::out_of_range& e) {
88864       {
88865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88866       };
88867     } catch (std::exception& e) {
88868       {
88869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88870       };
88871     } catch (Dali::DaliException e) {
88872       {
88873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88874       };
88875     } catch (...) {
88876       {
88877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88878       };
88879     }
88880   }
88881
88882   jresult = (int)result;
88883   return jresult;
88884 }
88885
88886
88887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88888   void * jresult ;
88889   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88890   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88891
88892   arg1 = (Dali::Toolkit::Popup *)jarg1;
88893   {
88894     try {
88895       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88896     } catch (std::out_of_range& e) {
88897       {
88898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88899       };
88900     } catch (std::exception& e) {
88901       {
88902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88903       };
88904     } catch (Dali::DaliException e) {
88905       {
88906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88907       };
88908     } catch (...) {
88909       {
88910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88911       };
88912     }
88913   }
88914
88915   jresult = (void *)result;
88916   return jresult;
88917 }
88918
88919
88920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88921   void * jresult ;
88922   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88923   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88924
88925   arg1 = (Dali::Toolkit::Popup *)jarg1;
88926   {
88927     try {
88928       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88929     } catch (std::out_of_range& e) {
88930       {
88931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88932       };
88933     } catch (std::exception& e) {
88934       {
88935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88936       };
88937     } catch (Dali::DaliException e) {
88938       {
88939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88940       };
88941     } catch (...) {
88942       {
88943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88944       };
88945     }
88946   }
88947
88948   jresult = (void *)result;
88949   return jresult;
88950 }
88951
88952
88953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88954   void * jresult ;
88955   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88956   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88957
88958   arg1 = (Dali::Toolkit::Popup *)jarg1;
88959   {
88960     try {
88961       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88962     } catch (std::out_of_range& e) {
88963       {
88964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88965       };
88966     } catch (std::exception& e) {
88967       {
88968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88969       };
88970     } catch (Dali::DaliException e) {
88971       {
88972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88973       };
88974     } catch (...) {
88975       {
88976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88977       };
88978     }
88979   }
88980
88981   jresult = (void *)result;
88982   return jresult;
88983 }
88984
88985
88986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88987   void * jresult ;
88988   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88989   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88990
88991   arg1 = (Dali::Toolkit::Popup *)jarg1;
88992   {
88993     try {
88994       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88995     } catch (std::out_of_range& e) {
88996       {
88997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88998       };
88999     } catch (std::exception& e) {
89000       {
89001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89002       };
89003     } catch (Dali::DaliException e) {
89004       {
89005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89006       };
89007     } catch (...) {
89008       {
89009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89010       };
89011     }
89012   }
89013
89014   jresult = (void *)result;
89015   return jresult;
89016 }
89017
89018
89019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
89020   void * jresult ;
89021   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89022   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89023
89024   arg1 = (Dali::Toolkit::Popup *)jarg1;
89025   {
89026     try {
89027       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
89028     } catch (std::out_of_range& e) {
89029       {
89030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89031       };
89032     } catch (std::exception& e) {
89033       {
89034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89035       };
89036     } catch (Dali::DaliException e) {
89037       {
89038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89039       };
89040     } catch (...) {
89041       {
89042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89043       };
89044     }
89045   }
89046
89047   jresult = (void *)result;
89048   return jresult;
89049 }
89050
89051
89052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
89053   int jresult ;
89054   int result;
89055
89056   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
89057   jresult = (int)result;
89058   return jresult;
89059 }
89060
89061
89062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
89063   int jresult ;
89064   int result;
89065
89066   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
89067   jresult = (int)result;
89068   return jresult;
89069 }
89070
89071
89072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89073   int jresult ;
89074   int result;
89075
89076   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89077   jresult = (int)result;
89078   return jresult;
89079 }
89080
89081
89082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89083   int jresult ;
89084   int result;
89085
89086   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89087   jresult = (int)result;
89088   return jresult;
89089 }
89090
89091
89092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89093   int jresult ;
89094   int result;
89095
89096   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89097   jresult = (int)result;
89098   return jresult;
89099 }
89100
89101
89102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89103   int jresult ;
89104   int result;
89105
89106   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89107   jresult = (int)result;
89108   return jresult;
89109 }
89110
89111
89112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89113   int jresult ;
89114   int result;
89115
89116   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89117   jresult = (int)result;
89118   return jresult;
89119 }
89120
89121
89122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89123   int jresult ;
89124   int result;
89125
89126   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89127   jresult = (int)result;
89128   return jresult;
89129 }
89130
89131
89132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89133   int jresult ;
89134   int result;
89135
89136   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89137   jresult = (int)result;
89138   return jresult;
89139 }
89140
89141
89142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89143   void * jresult ;
89144   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89145
89146   {
89147     try {
89148       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89149     } catch (std::out_of_range& e) {
89150       {
89151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89152       };
89153     } catch (std::exception& e) {
89154       {
89155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89156       };
89157     } catch (Dali::DaliException e) {
89158       {
89159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89160       };
89161     } catch (...) {
89162       {
89163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89164       };
89165     }
89166   }
89167
89168   jresult = (void *)result;
89169   return jresult;
89170 }
89171
89172
89173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89174   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89175
89176   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89177   {
89178     try {
89179       delete arg1;
89180     } catch (std::out_of_range& e) {
89181       {
89182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89183       };
89184     } catch (std::exception& e) {
89185       {
89186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89187       };
89188     } catch (Dali::DaliException e) {
89189       {
89190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89191       };
89192     } catch (...) {
89193       {
89194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89195       };
89196     }
89197   }
89198
89199 }
89200
89201
89202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89203   void * jresult ;
89204   Dali::Toolkit::ProgressBar result;
89205
89206   {
89207     try {
89208       result = Dali::Toolkit::ProgressBar::New();
89209     } catch (std::out_of_range& e) {
89210       {
89211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89212       };
89213     } catch (std::exception& e) {
89214       {
89215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89216       };
89217     } catch (Dali::DaliException e) {
89218       {
89219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89220       };
89221     } catch (...) {
89222       {
89223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89224       };
89225     }
89226   }
89227
89228   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89229   return jresult;
89230 }
89231
89232
89233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89234   void * jresult ;
89235   Dali::Toolkit::ProgressBar *result = 0 ;
89236
89237   {
89238     try {
89239       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89240     } catch (std::out_of_range& e) {
89241       {
89242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89243       };
89244     } catch (std::exception& e) {
89245       {
89246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89247       };
89248     } catch (Dali::DaliException e) {
89249       {
89250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89251       };
89252     } catch (...) {
89253       {
89254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89255       };
89256     }
89257   }
89258
89259   jresult = (void *)result;
89260   return jresult;
89261 }
89262
89263
89264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89265   void * jresult ;
89266   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89267   Dali::Toolkit::ProgressBar *result = 0 ;
89268
89269   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89270   if (!arg1) {
89271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89272     return 0;
89273   }
89274   {
89275     try {
89276       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89277     } catch (std::out_of_range& e) {
89278       {
89279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89280       };
89281     } catch (std::exception& e) {
89282       {
89283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89284       };
89285     } catch (Dali::DaliException e) {
89286       {
89287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89288       };
89289     } catch (...) {
89290       {
89291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89292       };
89293     }
89294   }
89295
89296   jresult = (void *)result;
89297   return jresult;
89298 }
89299
89300
89301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89302   void * jresult ;
89303   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89304   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89305   Dali::Toolkit::ProgressBar *result = 0 ;
89306
89307   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89308   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89309   if (!arg2) {
89310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89311     return 0;
89312   }
89313   {
89314     try {
89315       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89316     } catch (std::out_of_range& e) {
89317       {
89318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89319       };
89320     } catch (std::exception& e) {
89321       {
89322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89323       };
89324     } catch (Dali::DaliException e) {
89325       {
89326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89327       };
89328     } catch (...) {
89329       {
89330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89331       };
89332     }
89333   }
89334
89335   jresult = (void *)result;
89336   return jresult;
89337 }
89338
89339
89340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89341   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89342
89343   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89344   {
89345     try {
89346       delete arg1;
89347     } catch (std::out_of_range& e) {
89348       {
89349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89350       };
89351     } catch (std::exception& e) {
89352       {
89353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89354       };
89355     } catch (Dali::DaliException e) {
89356       {
89357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89358       };
89359     } catch (...) {
89360       {
89361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89362       };
89363     }
89364   }
89365
89366 }
89367
89368
89369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89370   void * jresult ;
89371   Dali::BaseHandle arg1 ;
89372   Dali::BaseHandle *argp1 ;
89373   Dali::Toolkit::ProgressBar result;
89374
89375   argp1 = (Dali::BaseHandle *)jarg1;
89376   if (!argp1) {
89377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89378     return 0;
89379   }
89380   arg1 = *argp1;
89381   {
89382     try {
89383       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89384     } catch (std::out_of_range& e) {
89385       {
89386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89387       };
89388     } catch (std::exception& e) {
89389       {
89390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89391       };
89392     } catch (Dali::DaliException e) {
89393       {
89394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89395       };
89396     } catch (...) {
89397       {
89398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89399       };
89400     }
89401   }
89402
89403   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89404   return jresult;
89405 }
89406
89407
89408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89409   void * jresult ;
89410   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89411   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89412
89413   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89414   {
89415     try {
89416       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89417     } catch (std::out_of_range& e) {
89418       {
89419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89420       };
89421     } catch (std::exception& e) {
89422       {
89423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89424       };
89425     } catch (Dali::DaliException e) {
89426       {
89427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89428       };
89429     } catch (...) {
89430       {
89431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89432       };
89433     }
89434   }
89435
89436   jresult = (void *)result;
89437   return jresult;
89438 }
89439
89440
89441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89442   void * jresult ;
89443   Dali::Toolkit::GaussianBlurView *result = 0 ;
89444
89445   {
89446     try {
89447       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89448     } catch (std::out_of_range& e) {
89449       {
89450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89451       };
89452     } catch (std::exception& e) {
89453       {
89454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89455       };
89456     } catch (Dali::DaliException e) {
89457       {
89458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89459       };
89460     } catch (...) {
89461       {
89462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89463       };
89464     }
89465   }
89466
89467   jresult = (void *)result;
89468   return jresult;
89469 }
89470
89471
89472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89473   void * jresult ;
89474   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89475   Dali::Toolkit::GaussianBlurView *result = 0 ;
89476
89477   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89478   if (!arg1) {
89479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89480     return 0;
89481   }
89482   {
89483     try {
89484       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89485     } catch (std::out_of_range& e) {
89486       {
89487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89488       };
89489     } catch (std::exception& e) {
89490       {
89491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89492       };
89493     } catch (Dali::DaliException e) {
89494       {
89495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89496       };
89497     } catch (...) {
89498       {
89499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89500       };
89501     }
89502   }
89503
89504   jresult = (void *)result;
89505   return jresult;
89506 }
89507
89508
89509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89510   void * jresult ;
89511   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89512   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89513   Dali::Toolkit::GaussianBlurView *result = 0 ;
89514
89515   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89516   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89517   if (!arg2) {
89518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89519     return 0;
89520   }
89521   {
89522     try {
89523       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89524     } catch (std::out_of_range& e) {
89525       {
89526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89527       };
89528     } catch (std::exception& e) {
89529       {
89530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89531       };
89532     } catch (Dali::DaliException e) {
89533       {
89534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89535       };
89536     } catch (...) {
89537       {
89538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89539       };
89540     }
89541   }
89542
89543   jresult = (void *)result;
89544   return jresult;
89545 }
89546
89547
89548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89549   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89550
89551   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89552   {
89553     try {
89554       delete arg1;
89555     } catch (std::out_of_range& e) {
89556       {
89557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89558       };
89559     } catch (std::exception& e) {
89560       {
89561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89562       };
89563     } catch (Dali::DaliException e) {
89564       {
89565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89566       };
89567     } catch (...) {
89568       {
89569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89570       };
89571     }
89572   }
89573
89574 }
89575
89576
89577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89578   void * jresult ;
89579   Dali::BaseHandle arg1 ;
89580   Dali::BaseHandle *argp1 ;
89581   Dali::Toolkit::GaussianBlurView result;
89582
89583   argp1 = (Dali::BaseHandle *)jarg1;
89584   if (!argp1) {
89585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89586     return 0;
89587   }
89588   arg1 = *argp1;
89589   {
89590     try {
89591       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89592     } catch (std::out_of_range& e) {
89593       {
89594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89595       };
89596     } catch (std::exception& e) {
89597       {
89598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89599       };
89600     } catch (Dali::DaliException e) {
89601       {
89602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89603       };
89604     } catch (...) {
89605       {
89606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89607       };
89608     }
89609   }
89610
89611   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89612   return jresult;
89613 }
89614
89615
89616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89617   void * jresult ;
89618   Dali::Toolkit::GaussianBlurView result;
89619
89620   {
89621     try {
89622       result = Dali::Toolkit::GaussianBlurView::New();
89623     } catch (std::out_of_range& e) {
89624       {
89625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89626       };
89627     } catch (std::exception& e) {
89628       {
89629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89630       };
89631     } catch (Dali::DaliException e) {
89632       {
89633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89634       };
89635     } catch (...) {
89636       {
89637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89638       };
89639     }
89640   }
89641
89642   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89643   return jresult;
89644 }
89645
89646
89647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89648   void * jresult ;
89649   unsigned int arg1 ;
89650   float arg2 ;
89651   Dali::Pixel::Format arg3 ;
89652   float arg4 ;
89653   float arg5 ;
89654   bool arg6 ;
89655   Dali::Toolkit::GaussianBlurView result;
89656
89657   arg1 = (unsigned int)jarg1;
89658   arg2 = (float)jarg2;
89659   arg3 = (Dali::Pixel::Format)jarg3;
89660   arg4 = (float)jarg4;
89661   arg5 = (float)jarg5;
89662   arg6 = jarg6 ? true : false;
89663   {
89664     try {
89665       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89666     } catch (std::out_of_range& e) {
89667       {
89668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89669       };
89670     } catch (std::exception& e) {
89671       {
89672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89673       };
89674     } catch (Dali::DaliException e) {
89675       {
89676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89677       };
89678     } catch (...) {
89679       {
89680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89681       };
89682     }
89683   }
89684
89685   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89686   return jresult;
89687 }
89688
89689
89690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89691   void * jresult ;
89692   unsigned int arg1 ;
89693   float arg2 ;
89694   Dali::Pixel::Format arg3 ;
89695   float arg4 ;
89696   float arg5 ;
89697   Dali::Toolkit::GaussianBlurView result;
89698
89699   arg1 = (unsigned int)jarg1;
89700   arg2 = (float)jarg2;
89701   arg3 = (Dali::Pixel::Format)jarg3;
89702   arg4 = (float)jarg4;
89703   arg5 = (float)jarg5;
89704   {
89705     try {
89706       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89707     } catch (std::out_of_range& e) {
89708       {
89709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89710       };
89711     } catch (std::exception& e) {
89712       {
89713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89714       };
89715     } catch (Dali::DaliException e) {
89716       {
89717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89718       };
89719     } catch (...) {
89720       {
89721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89722       };
89723     }
89724   }
89725
89726   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89727   return jresult;
89728 }
89729
89730
89731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89732   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89733   Dali::Actor arg2 ;
89734   Dali::Actor *argp2 ;
89735
89736   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89737   argp2 = (Dali::Actor *)jarg2;
89738   if (!argp2) {
89739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89740     return ;
89741   }
89742   arg2 = *argp2;
89743   {
89744     try {
89745       (arg1)->Add(arg2);
89746     } catch (std::out_of_range& e) {
89747       {
89748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89749       };
89750     } catch (std::exception& e) {
89751       {
89752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89753       };
89754     } catch (Dali::DaliException e) {
89755       {
89756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89757       };
89758     } catch (...) {
89759       {
89760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89761       };
89762     }
89763   }
89764
89765 }
89766
89767
89768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89769   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89770   Dali::Actor arg2 ;
89771   Dali::Actor *argp2 ;
89772
89773   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89774   argp2 = (Dali::Actor *)jarg2;
89775   if (!argp2) {
89776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89777     return ;
89778   }
89779   arg2 = *argp2;
89780   {
89781     try {
89782       (arg1)->Remove(arg2);
89783     } catch (std::out_of_range& e) {
89784       {
89785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89786       };
89787     } catch (std::exception& e) {
89788       {
89789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89790       };
89791     } catch (Dali::DaliException e) {
89792       {
89793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89794       };
89795     } catch (...) {
89796       {
89797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89798       };
89799     }
89800   }
89801
89802 }
89803
89804
89805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89806   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89807
89808   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89809   {
89810     try {
89811       (arg1)->Activate();
89812     } catch (std::out_of_range& e) {
89813       {
89814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89815       };
89816     } catch (std::exception& e) {
89817       {
89818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89819       };
89820     } catch (Dali::DaliException e) {
89821       {
89822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89823       };
89824     } catch (...) {
89825       {
89826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89827       };
89828     }
89829   }
89830
89831 }
89832
89833
89834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89835   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89836
89837   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89838   {
89839     try {
89840       (arg1)->ActivateOnce();
89841     } catch (std::out_of_range& e) {
89842       {
89843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89844       };
89845     } catch (std::exception& e) {
89846       {
89847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89848       };
89849     } catch (Dali::DaliException e) {
89850       {
89851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89852       };
89853     } catch (...) {
89854       {
89855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89856       };
89857     }
89858   }
89859
89860 }
89861
89862
89863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89864   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89865
89866   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89867   {
89868     try {
89869       (arg1)->Deactivate();
89870     } catch (std::out_of_range& e) {
89871       {
89872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89873       };
89874     } catch (std::exception& e) {
89875       {
89876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89877       };
89878     } catch (Dali::DaliException e) {
89879       {
89880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89881       };
89882     } catch (...) {
89883       {
89884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89885       };
89886     }
89887   }
89888
89889 }
89890
89891
89892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89893   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89894   Dali::Image arg2 ;
89895   Dali::FrameBufferImage arg3 ;
89896   Dali::Image *argp2 ;
89897   Dali::FrameBufferImage *argp3 ;
89898
89899   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89900   argp2 = (Dali::Image *)jarg2;
89901   if (!argp2) {
89902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89903     return ;
89904   }
89905   arg2 = *argp2;
89906   argp3 = (Dali::FrameBufferImage *)jarg3;
89907   if (!argp3) {
89908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89909     return ;
89910   }
89911   arg3 = *argp3;
89912   {
89913     try {
89914       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89915     } catch (std::out_of_range& e) {
89916       {
89917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89918       };
89919     } catch (std::exception& e) {
89920       {
89921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89922       };
89923     } catch (Dali::DaliException e) {
89924       {
89925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89926       };
89927     } catch (...) {
89928       {
89929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89930       };
89931     }
89932   }
89933
89934 }
89935
89936
89937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89938   int jresult ;
89939   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89940   Dali::Property::Index result;
89941
89942   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89943   {
89944     try {
89945       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89946     } catch (std::out_of_range& e) {
89947       {
89948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89949       };
89950     } catch (std::exception& e) {
89951       {
89952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89953       };
89954     } catch (Dali::DaliException e) {
89955       {
89956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89957       };
89958     } catch (...) {
89959       {
89960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89961       };
89962     }
89963   }
89964
89965   jresult = result;
89966   return jresult;
89967 }
89968
89969
89970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89971   void * jresult ;
89972   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89973   Dali::FrameBufferImage result;
89974
89975   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89976   {
89977     try {
89978       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89979     } catch (std::out_of_range& e) {
89980       {
89981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89982       };
89983     } catch (std::exception& e) {
89984       {
89985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89986       };
89987     } catch (Dali::DaliException e) {
89988       {
89989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89990       };
89991     } catch (...) {
89992       {
89993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89994       };
89995     }
89996   }
89997
89998   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89999   return jresult;
90000 }
90001
90002
90003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
90004   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90005   Dali::Vector4 *arg2 = 0 ;
90006
90007   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90008   arg2 = (Dali::Vector4 *)jarg2;
90009   if (!arg2) {
90010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
90011     return ;
90012   }
90013   {
90014     try {
90015       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
90016     } catch (std::out_of_range& e) {
90017       {
90018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90019       };
90020     } catch (std::exception& e) {
90021       {
90022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90023       };
90024     } catch (Dali::DaliException e) {
90025       {
90026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90027       };
90028     } catch (...) {
90029       {
90030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90031       };
90032     }
90033   }
90034
90035 }
90036
90037
90038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
90039   void * jresult ;
90040   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90041   Dali::Vector4 result;
90042
90043   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90044   {
90045     try {
90046       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
90047     } catch (std::out_of_range& e) {
90048       {
90049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90050       };
90051     } catch (std::exception& e) {
90052       {
90053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90054       };
90055     } catch (Dali::DaliException e) {
90056       {
90057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90058       };
90059     } catch (...) {
90060       {
90061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90062       };
90063     }
90064   }
90065
90066   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
90067   return jresult;
90068 }
90069
90070
90071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90072   void * jresult ;
90073   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90074   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90075
90076   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90077   {
90078     try {
90079       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90080     } catch (std::out_of_range& e) {
90081       {
90082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90083       };
90084     } catch (std::exception& e) {
90085       {
90086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90087       };
90088     } catch (Dali::DaliException e) {
90089       {
90090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90091       };
90092     } catch (...) {
90093       {
90094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90095       };
90096     }
90097   }
90098
90099   jresult = (void *)result;
90100   return jresult;
90101 }
90102
90103
90104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90105   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90106
90107   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90108   {
90109     try {
90110       delete arg1;
90111     } catch (std::out_of_range& e) {
90112       {
90113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90114       };
90115     } catch (std::exception& e) {
90116       {
90117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90118       };
90119     } catch (Dali::DaliException e) {
90120       {
90121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90122       };
90123     } catch (...) {
90124       {
90125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90126       };
90127     }
90128   }
90129
90130 }
90131
90132
90133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90134   unsigned int jresult ;
90135   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90136   unsigned int result;
90137
90138   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90139   {
90140     try {
90141       result = (unsigned int)(arg1)->GetNumberOfPages();
90142     } catch (std::out_of_range& e) {
90143       {
90144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90145       };
90146     } catch (std::exception& e) {
90147       {
90148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90149       };
90150     } catch (Dali::DaliException e) {
90151       {
90152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90153       };
90154     } catch (...) {
90155       {
90156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90157       };
90158     }
90159   }
90160
90161   jresult = result;
90162   return jresult;
90163 }
90164
90165
90166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90167   void * jresult ;
90168   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90169   unsigned int arg2 ;
90170   Dali::Texture result;
90171
90172   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90173   arg2 = (unsigned int)jarg2;
90174   {
90175     try {
90176       result = (arg1)->NewPage(arg2);
90177     } catch (std::out_of_range& e) {
90178       {
90179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90180       };
90181     } catch (std::exception& e) {
90182       {
90183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90184       };
90185     } catch (Dali::DaliException e) {
90186       {
90187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90188       };
90189     } catch (...) {
90190       {
90191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90192       };
90193     }
90194   }
90195
90196   jresult = new Dali::Texture((const Dali::Texture &)result);
90197   return jresult;
90198 }
90199
90200
90201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90202   int jresult ;
90203   int result;
90204
90205   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90206   jresult = (int)result;
90207   return jresult;
90208 }
90209
90210
90211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90212   int jresult ;
90213   int result;
90214
90215   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90216   jresult = (int)result;
90217   return jresult;
90218 }
90219
90220
90221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90222   int jresult ;
90223   int result;
90224
90225   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90226   jresult = (int)result;
90227   return jresult;
90228 }
90229
90230
90231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90232   void * jresult ;
90233   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90234
90235   {
90236     try {
90237       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
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 = (void *)result;
90258   return jresult;
90259 }
90260
90261
90262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90263   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90264
90265   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90266   {
90267     try {
90268       delete arg1;
90269     } catch (std::out_of_range& e) {
90270       {
90271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90272       };
90273     } catch (std::exception& e) {
90274       {
90275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90276       };
90277     } catch (Dali::DaliException e) {
90278       {
90279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90280       };
90281     } catch (...) {
90282       {
90283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90284       };
90285     }
90286   }
90287
90288 }
90289
90290
90291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90292   void * jresult ;
90293   Dali::Toolkit::PageTurnView *result = 0 ;
90294
90295   {
90296     try {
90297       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90298     } catch (std::out_of_range& e) {
90299       {
90300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90301       };
90302     } catch (std::exception& e) {
90303       {
90304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90305       };
90306     } catch (Dali::DaliException e) {
90307       {
90308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90309       };
90310     } catch (...) {
90311       {
90312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90313       };
90314     }
90315   }
90316
90317   jresult = (void *)result;
90318   return jresult;
90319 }
90320
90321
90322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90323   void * jresult ;
90324   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90325   Dali::Toolkit::PageTurnView *result = 0 ;
90326
90327   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90328   if (!arg1) {
90329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90330     return 0;
90331   }
90332   {
90333     try {
90334       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90335     } catch (std::out_of_range& e) {
90336       {
90337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90338       };
90339     } catch (std::exception& e) {
90340       {
90341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90342       };
90343     } catch (Dali::DaliException e) {
90344       {
90345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90346       };
90347     } catch (...) {
90348       {
90349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90350       };
90351     }
90352   }
90353
90354   jresult = (void *)result;
90355   return jresult;
90356 }
90357
90358
90359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90360   void * jresult ;
90361   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90362   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90363   Dali::Toolkit::PageTurnView *result = 0 ;
90364
90365   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90366   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90367   if (!arg2) {
90368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90369     return 0;
90370   }
90371   {
90372     try {
90373       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90374     } catch (std::out_of_range& e) {
90375       {
90376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90377       };
90378     } catch (std::exception& e) {
90379       {
90380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90381       };
90382     } catch (Dali::DaliException e) {
90383       {
90384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90385       };
90386     } catch (...) {
90387       {
90388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90389       };
90390     }
90391   }
90392
90393   jresult = (void *)result;
90394   return jresult;
90395 }
90396
90397
90398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90399   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90400
90401   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90402   {
90403     try {
90404       delete arg1;
90405     } catch (std::out_of_range& e) {
90406       {
90407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90408       };
90409     } catch (std::exception& e) {
90410       {
90411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90412       };
90413     } catch (Dali::DaliException e) {
90414       {
90415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90416       };
90417     } catch (...) {
90418       {
90419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90420       };
90421     }
90422   }
90423
90424 }
90425
90426
90427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90428   void * jresult ;
90429   Dali::BaseHandle arg1 ;
90430   Dali::BaseHandle *argp1 ;
90431   Dali::Toolkit::PageTurnView result;
90432
90433   argp1 = (Dali::BaseHandle *)jarg1;
90434   if (!argp1) {
90435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90436     return 0;
90437   }
90438   arg1 = *argp1;
90439   {
90440     try {
90441       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90442     } catch (std::out_of_range& e) {
90443       {
90444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90445       };
90446     } catch (std::exception& e) {
90447       {
90448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90449       };
90450     } catch (Dali::DaliException e) {
90451       {
90452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90453       };
90454     } catch (...) {
90455       {
90456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90457       };
90458     }
90459   }
90460
90461   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90462   return jresult;
90463 }
90464
90465
90466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90467   void * jresult ;
90468   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90469   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90470
90471   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90472   {
90473     try {
90474       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90475     } catch (std::out_of_range& e) {
90476       {
90477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90478       };
90479     } catch (std::exception& e) {
90480       {
90481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90482       };
90483     } catch (Dali::DaliException e) {
90484       {
90485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90486       };
90487     } catch (...) {
90488       {
90489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90490       };
90491     }
90492   }
90493
90494   jresult = (void *)result;
90495   return jresult;
90496 }
90497
90498
90499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90500   void * jresult ;
90501   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90502   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90503
90504   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90505   {
90506     try {
90507       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90508     } catch (std::out_of_range& e) {
90509       {
90510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90511       };
90512     } catch (std::exception& e) {
90513       {
90514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90515       };
90516     } catch (Dali::DaliException e) {
90517       {
90518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90519       };
90520     } catch (...) {
90521       {
90522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90523       };
90524     }
90525   }
90526
90527   jresult = (void *)result;
90528   return jresult;
90529 }
90530
90531
90532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90533   void * jresult ;
90534   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90535   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90536
90537   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90538   {
90539     try {
90540       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90541     } catch (std::out_of_range& e) {
90542       {
90543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90544       };
90545     } catch (std::exception& e) {
90546       {
90547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90548       };
90549     } catch (Dali::DaliException e) {
90550       {
90551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90552       };
90553     } catch (...) {
90554       {
90555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90556       };
90557     }
90558   }
90559
90560   jresult = (void *)result;
90561   return jresult;
90562 }
90563
90564
90565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90566   void * jresult ;
90567   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90568   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90569
90570   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90571   {
90572     try {
90573       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90574     } catch (std::out_of_range& e) {
90575       {
90576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90577       };
90578     } catch (std::exception& e) {
90579       {
90580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90581       };
90582     } catch (Dali::DaliException e) {
90583       {
90584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90585       };
90586     } catch (...) {
90587       {
90588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90589       };
90590     }
90591   }
90592
90593   jresult = (void *)result;
90594   return jresult;
90595 }
90596
90597
90598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90599   void * jresult ;
90600   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90601
90602   {
90603     try {
90604       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90605     } catch (std::out_of_range& e) {
90606       {
90607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90608       };
90609     } catch (std::exception& e) {
90610       {
90611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90612       };
90613     } catch (Dali::DaliException e) {
90614       {
90615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90616       };
90617     } catch (...) {
90618       {
90619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90620       };
90621     }
90622   }
90623
90624   jresult = (void *)result;
90625   return jresult;
90626 }
90627
90628
90629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90630   void * jresult ;
90631   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90632   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90633
90634   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90635   if (!arg1) {
90636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90637     return 0;
90638   }
90639   {
90640     try {
90641       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90642     } catch (std::out_of_range& e) {
90643       {
90644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90645       };
90646     } catch (std::exception& e) {
90647       {
90648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90649       };
90650     } catch (Dali::DaliException e) {
90651       {
90652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90653       };
90654     } catch (...) {
90655       {
90656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90657       };
90658     }
90659   }
90660
90661   jresult = (void *)result;
90662   return jresult;
90663 }
90664
90665
90666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90667   void * jresult ;
90668   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90669   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90670   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90671
90672   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90673   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90674   if (!arg2) {
90675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90676     return 0;
90677   }
90678   {
90679     try {
90680       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90681     } catch (std::out_of_range& e) {
90682       {
90683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90684       };
90685     } catch (std::exception& e) {
90686       {
90687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90688       };
90689     } catch (Dali::DaliException e) {
90690       {
90691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90692       };
90693     } catch (...) {
90694       {
90695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90696       };
90697     }
90698   }
90699
90700   jresult = (void *)result;
90701   return jresult;
90702 }
90703
90704
90705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90706   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90707
90708   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90709   {
90710     try {
90711       delete arg1;
90712     } catch (std::out_of_range& e) {
90713       {
90714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90715       };
90716     } catch (std::exception& e) {
90717       {
90718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90719       };
90720     } catch (Dali::DaliException e) {
90721       {
90722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90723       };
90724     } catch (...) {
90725       {
90726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90727       };
90728     }
90729   }
90730
90731 }
90732
90733
90734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90735   void * jresult ;
90736   Dali::Toolkit::PageFactory *arg1 = 0 ;
90737   Dali::Vector2 *arg2 = 0 ;
90738   Dali::Toolkit::PageTurnLandscapeView result;
90739
90740   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90741   if (!arg1) {
90742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90743     return 0;
90744   }
90745   arg2 = (Dali::Vector2 *)jarg2;
90746   if (!arg2) {
90747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90748     return 0;
90749   }
90750   {
90751     try {
90752       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90753     } catch (std::out_of_range& e) {
90754       {
90755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90756       };
90757     } catch (std::exception& e) {
90758       {
90759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90760       };
90761     } catch (Dali::DaliException e) {
90762       {
90763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90764       };
90765     } catch (...) {
90766       {
90767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90768       };
90769     }
90770   }
90771
90772   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90773   return jresult;
90774 }
90775
90776
90777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90778   void * jresult ;
90779   Dali::BaseHandle arg1 ;
90780   Dali::BaseHandle *argp1 ;
90781   Dali::Toolkit::PageTurnLandscapeView result;
90782
90783   argp1 = (Dali::BaseHandle *)jarg1;
90784   if (!argp1) {
90785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90786     return 0;
90787   }
90788   arg1 = *argp1;
90789   {
90790     try {
90791       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90792     } catch (std::out_of_range& e) {
90793       {
90794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90795       };
90796     } catch (std::exception& e) {
90797       {
90798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90799       };
90800     } catch (Dali::DaliException e) {
90801       {
90802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90803       };
90804     } catch (...) {
90805       {
90806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90807       };
90808     }
90809   }
90810
90811   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90812   return jresult;
90813 }
90814
90815
90816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90817   void * jresult ;
90818   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90819
90820   {
90821     try {
90822       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90823     } catch (std::out_of_range& e) {
90824       {
90825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90826       };
90827     } catch (std::exception& e) {
90828       {
90829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90830       };
90831     } catch (Dali::DaliException e) {
90832       {
90833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90834       };
90835     } catch (...) {
90836       {
90837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90838       };
90839     }
90840   }
90841
90842   jresult = (void *)result;
90843   return jresult;
90844 }
90845
90846
90847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90848   void * jresult ;
90849   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90850   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90851
90852   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90853   if (!arg1) {
90854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90855     return 0;
90856   }
90857   {
90858     try {
90859       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90860     } catch (std::out_of_range& e) {
90861       {
90862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90863       };
90864     } catch (std::exception& e) {
90865       {
90866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90867       };
90868     } catch (Dali::DaliException e) {
90869       {
90870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90871       };
90872     } catch (...) {
90873       {
90874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90875       };
90876     }
90877   }
90878
90879   jresult = (void *)result;
90880   return jresult;
90881 }
90882
90883
90884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90885   void * jresult ;
90886   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90887   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90888   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90889
90890   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90891   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90892   if (!arg2) {
90893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90894     return 0;
90895   }
90896   {
90897     try {
90898       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90899     } catch (std::out_of_range& e) {
90900       {
90901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90902       };
90903     } catch (std::exception& e) {
90904       {
90905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90906       };
90907     } catch (Dali::DaliException e) {
90908       {
90909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90910       };
90911     } catch (...) {
90912       {
90913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90914       };
90915     }
90916   }
90917
90918   jresult = (void *)result;
90919   return jresult;
90920 }
90921
90922
90923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90924   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90925
90926   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90927   {
90928     try {
90929       delete arg1;
90930     } catch (std::out_of_range& e) {
90931       {
90932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90933       };
90934     } catch (std::exception& e) {
90935       {
90936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90937       };
90938     } catch (Dali::DaliException e) {
90939       {
90940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90941       };
90942     } catch (...) {
90943       {
90944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90945       };
90946     }
90947   }
90948
90949 }
90950
90951
90952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90953   void * jresult ;
90954   Dali::Toolkit::PageFactory *arg1 = 0 ;
90955   Dali::Vector2 *arg2 = 0 ;
90956   Dali::Toolkit::PageTurnPortraitView result;
90957
90958   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90959   if (!arg1) {
90960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90961     return 0;
90962   }
90963   arg2 = (Dali::Vector2 *)jarg2;
90964   if (!arg2) {
90965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90966     return 0;
90967   }
90968   {
90969     try {
90970       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90971     } catch (std::out_of_range& e) {
90972       {
90973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90974       };
90975     } catch (std::exception& e) {
90976       {
90977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90978       };
90979     } catch (Dali::DaliException e) {
90980       {
90981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90982       };
90983     } catch (...) {
90984       {
90985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90986       };
90987     }
90988   }
90989
90990   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90991   return jresult;
90992 }
90993
90994
90995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90996   void * jresult ;
90997   Dali::BaseHandle arg1 ;
90998   Dali::BaseHandle *argp1 ;
90999   Dali::Toolkit::PageTurnPortraitView result;
91000
91001   argp1 = (Dali::BaseHandle *)jarg1;
91002   if (!argp1) {
91003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91004     return 0;
91005   }
91006   arg1 = *argp1;
91007   {
91008     try {
91009       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
91010     } catch (std::out_of_range& e) {
91011       {
91012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91013       };
91014     } catch (std::exception& e) {
91015       {
91016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91017       };
91018     } catch (Dali::DaliException e) {
91019       {
91020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91021       };
91022     } catch (...) {
91023       {
91024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91025       };
91026     }
91027   }
91028
91029   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91030   return jresult;
91031 }
91032
91033
91034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
91035   int jresult ;
91036   int result;
91037
91038   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
91039   jresult = (int)result;
91040   return jresult;
91041 }
91042
91043
91044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
91045   int jresult ;
91046   int result;
91047
91048   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
91049   jresult = (int)result;
91050   return jresult;
91051 }
91052
91053
91054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
91055   int jresult ;
91056   int result;
91057
91058   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
91059   jresult = (int)result;
91060   return jresult;
91061 }
91062
91063
91064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
91065   void * jresult ;
91066   Dali::Toolkit::ToggleButton::Property *result = 0 ;
91067
91068   {
91069     try {
91070       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91071     } catch (std::out_of_range& e) {
91072       {
91073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91074       };
91075     } catch (std::exception& e) {
91076       {
91077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91078       };
91079     } catch (Dali::DaliException e) {
91080       {
91081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91082       };
91083     } catch (...) {
91084       {
91085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91086       };
91087     }
91088   }
91089
91090   jresult = (void *)result;
91091   return jresult;
91092 }
91093
91094
91095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91096   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91097
91098   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91099   {
91100     try {
91101       delete arg1;
91102     } catch (std::out_of_range& e) {
91103       {
91104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91105       };
91106     } catch (std::exception& e) {
91107       {
91108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91109       };
91110     } catch (Dali::DaliException e) {
91111       {
91112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91113       };
91114     } catch (...) {
91115       {
91116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91117       };
91118     }
91119   }
91120
91121 }
91122
91123
91124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91125   void * jresult ;
91126   Dali::Toolkit::ToggleButton *result = 0 ;
91127
91128   {
91129     try {
91130       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91131     } catch (std::out_of_range& e) {
91132       {
91133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91134       };
91135     } catch (std::exception& e) {
91136       {
91137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91138       };
91139     } catch (Dali::DaliException e) {
91140       {
91141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91142       };
91143     } catch (...) {
91144       {
91145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91146       };
91147     }
91148   }
91149
91150   jresult = (void *)result;
91151   return jresult;
91152 }
91153
91154
91155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91156   void * jresult ;
91157   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91158   Dali::Toolkit::ToggleButton *result = 0 ;
91159
91160   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91161   if (!arg1) {
91162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91163     return 0;
91164   }
91165   {
91166     try {
91167       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
91168     } catch (std::out_of_range& e) {
91169       {
91170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91171       };
91172     } catch (std::exception& e) {
91173       {
91174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91175       };
91176     } catch (Dali::DaliException e) {
91177       {
91178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91179       };
91180     } catch (...) {
91181       {
91182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91183       };
91184     }
91185   }
91186
91187   jresult = (void *)result;
91188   return jresult;
91189 }
91190
91191
91192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
91193   void * jresult ;
91194   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91195   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91196   Dali::Toolkit::ToggleButton *result = 0 ;
91197
91198   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91199   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91200   if (!arg2) {
91201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91202     return 0;
91203   }
91204   {
91205     try {
91206       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91207     } catch (std::out_of_range& e) {
91208       {
91209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91210       };
91211     } catch (std::exception& e) {
91212       {
91213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91214       };
91215     } catch (Dali::DaliException e) {
91216       {
91217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91218       };
91219     } catch (...) {
91220       {
91221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91222       };
91223     }
91224   }
91225
91226   jresult = (void *)result;
91227   return jresult;
91228 }
91229
91230
91231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91232   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91233
91234   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91235   {
91236     try {
91237       delete arg1;
91238     } catch (std::out_of_range& e) {
91239       {
91240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91241       };
91242     } catch (std::exception& e) {
91243       {
91244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91245       };
91246     } catch (Dali::DaliException e) {
91247       {
91248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91249       };
91250     } catch (...) {
91251       {
91252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91253       };
91254     }
91255   }
91256
91257 }
91258
91259
91260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91261   void * jresult ;
91262   Dali::Toolkit::ToggleButton result;
91263
91264   {
91265     try {
91266       result = Dali::Toolkit::ToggleButton::New();
91267     } catch (std::out_of_range& e) {
91268       {
91269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91270       };
91271     } catch (std::exception& e) {
91272       {
91273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91274       };
91275     } catch (Dali::DaliException e) {
91276       {
91277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91278       };
91279     } catch (...) {
91280       {
91281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91282       };
91283     }
91284   }
91285
91286   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91287   return jresult;
91288 }
91289
91290
91291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91292   void * jresult ;
91293   Dali::BaseHandle arg1 ;
91294   Dali::BaseHandle *argp1 ;
91295   Dali::Toolkit::ToggleButton result;
91296
91297   argp1 = (Dali::BaseHandle *)jarg1;
91298   if (!argp1) {
91299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91300     return 0;
91301   }
91302   arg1 = *argp1;
91303   {
91304     try {
91305       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91306     } catch (std::out_of_range& e) {
91307       {
91308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91309       };
91310     } catch (std::exception& e) {
91311       {
91312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91313       };
91314     } catch (Dali::DaliException e) {
91315       {
91316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91317       };
91318     } catch (...) {
91319       {
91320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91321       };
91322     }
91323   }
91324
91325   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91326   return jresult;
91327 }
91328
91329
91330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91331   void * jresult ;
91332   Dali::Toolkit::Visual::Base *result = 0 ;
91333
91334   {
91335     try {
91336       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91337     } catch (std::out_of_range& e) {
91338       {
91339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91340       };
91341     } catch (std::exception& e) {
91342       {
91343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91344       };
91345     } catch (Dali::DaliException e) {
91346       {
91347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91348       };
91349     } catch (...) {
91350       {
91351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91352       };
91353     }
91354   }
91355
91356   jresult = (void *)result;
91357   return jresult;
91358 }
91359
91360
91361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91362   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91363
91364   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91365   {
91366     try {
91367       delete arg1;
91368     } catch (std::out_of_range& e) {
91369       {
91370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91371       };
91372     } catch (std::exception& e) {
91373       {
91374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91375       };
91376     } catch (Dali::DaliException e) {
91377       {
91378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91379       };
91380     } catch (...) {
91381       {
91382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91383       };
91384     }
91385   }
91386
91387 }
91388
91389
91390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91391   void * jresult ;
91392   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91393   Dali::Toolkit::Visual::Base *result = 0 ;
91394
91395   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91396   if (!arg1) {
91397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91398     return 0;
91399   }
91400   {
91401     try {
91402       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91403     } catch (std::out_of_range& e) {
91404       {
91405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91406       };
91407     } catch (std::exception& e) {
91408       {
91409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91410       };
91411     } catch (Dali::DaliException e) {
91412       {
91413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91414       };
91415     } catch (...) {
91416       {
91417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91418       };
91419     }
91420   }
91421
91422   jresult = (void *)result;
91423   return jresult;
91424 }
91425
91426
91427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91428   void * jresult ;
91429   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91430   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91431   Dali::Toolkit::Visual::Base *result = 0 ;
91432
91433   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91434   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91435   if (!arg2) {
91436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91437     return 0;
91438   }
91439   {
91440     try {
91441       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91442     } catch (std::out_of_range& e) {
91443       {
91444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91445       };
91446     } catch (std::exception& e) {
91447       {
91448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91449       };
91450     } catch (Dali::DaliException e) {
91451       {
91452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91453       };
91454     } catch (...) {
91455       {
91456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91457       };
91458     }
91459   }
91460
91461   jresult = (void *)result;
91462   return jresult;
91463 }
91464
91465
91466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91467   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91468   std::string *arg2 = 0 ;
91469
91470   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91471   if (!jarg2) {
91472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91473     return ;
91474   }
91475   std::string arg2_str(jarg2);
91476   arg2 = &arg2_str;
91477   {
91478     try {
91479       (arg1)->SetName((std::string const &)*arg2);
91480     } catch (std::out_of_range& e) {
91481       {
91482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91483       };
91484     } catch (std::exception& e) {
91485       {
91486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91487       };
91488     } catch (Dali::DaliException e) {
91489       {
91490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91491       };
91492     } catch (...) {
91493       {
91494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91495       };
91496     }
91497   }
91498
91499
91500   //argout typemap for const std::string&
91501
91502 }
91503
91504
91505 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91506   char * jresult ;
91507   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91508   std::string *result = 0 ;
91509
91510   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91511   {
91512     try {
91513       result = (std::string *) &(arg1)->GetName();
91514     } catch (std::out_of_range& e) {
91515       {
91516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91517       };
91518     } catch (std::exception& e) {
91519       {
91520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91521       };
91522     } catch (Dali::DaliException e) {
91523       {
91524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91525       };
91526     } catch (...) {
91527       {
91528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91529       };
91530     }
91531   }
91532
91533   jresult = SWIG_csharp_string_callback(result->c_str());
91534   return jresult;
91535 }
91536
91537
91538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91539   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91540   Dali::Property::Map *arg2 = 0 ;
91541   Dali::Size arg3 ;
91542   Dali::Size *argp3 ;
91543
91544   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91545   arg2 = (Dali::Property::Map *)jarg2;
91546   if (!arg2) {
91547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91548     return ;
91549   }
91550   argp3 = (Dali::Size *)jarg3;
91551   if (!argp3) {
91552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91553     return ;
91554   }
91555   arg3 = *argp3;
91556   {
91557     try {
91558       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91559     } catch (std::out_of_range& e) {
91560       {
91561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91562       };
91563     } catch (std::exception& e) {
91564       {
91565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91566       };
91567     } catch (Dali::DaliException e) {
91568       {
91569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91570       };
91571     } catch (...) {
91572       {
91573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91574       };
91575     }
91576   }
91577
91578 }
91579
91580
91581 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91582   float jresult ;
91583   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91584   float arg2 ;
91585   float result;
91586
91587   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91588   arg2 = (float)jarg2;
91589   {
91590     try {
91591       result = (float)(arg1)->GetHeightForWidth(arg2);
91592     } catch (std::out_of_range& e) {
91593       {
91594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91595       };
91596     } catch (std::exception& e) {
91597       {
91598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91599       };
91600     } catch (Dali::DaliException e) {
91601       {
91602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91603       };
91604     } catch (...) {
91605       {
91606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91607       };
91608     }
91609   }
91610
91611   jresult = result;
91612   return jresult;
91613 }
91614
91615
91616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91617   float jresult ;
91618   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91619   float arg2 ;
91620   float result;
91621
91622   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91623   arg2 = (float)jarg2;
91624   {
91625     try {
91626       result = (float)(arg1)->GetWidthForHeight(arg2);
91627     } catch (std::out_of_range& e) {
91628       {
91629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91630       };
91631     } catch (std::exception& e) {
91632       {
91633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91634       };
91635     } catch (Dali::DaliException e) {
91636       {
91637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91638       };
91639     } catch (...) {
91640       {
91641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91642       };
91643     }
91644   }
91645
91646   jresult = result;
91647   return jresult;
91648 }
91649
91650
91651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91652   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91653   Dali::Vector2 *arg2 = 0 ;
91654
91655   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91656   arg2 = (Dali::Vector2 *)jarg2;
91657   if (!arg2) {
91658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91659     return ;
91660   }
91661   {
91662     try {
91663       (arg1)->GetNaturalSize(*arg2);
91664     } catch (std::out_of_range& e) {
91665       {
91666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91667       };
91668     } catch (std::exception& e) {
91669       {
91670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91671       };
91672     } catch (Dali::DaliException e) {
91673       {
91674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91675       };
91676     } catch (...) {
91677       {
91678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91679       };
91680     }
91681   }
91682
91683 }
91684
91685
91686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91687   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91688   float arg2 ;
91689
91690   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91691   arg2 = (int)jarg2;
91692   {
91693     try {
91694       (arg1)->SetDepthIndex(arg2);
91695     } catch (std::out_of_range& e) {
91696       {
91697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91698       };
91699     } catch (std::exception& e) {
91700       {
91701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91702       };
91703     } catch (Dali::DaliException e) {
91704       {
91705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91706       };
91707     } catch (...) {
91708       {
91709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91710       };
91711     }
91712   }
91713
91714 }
91715
91716
91717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91718   int jresult ;
91719   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91720   int result;
91721
91722   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91723   {
91724     try {
91725       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91726     } catch (std::out_of_range& e) {
91727       {
91728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91729       };
91730     } catch (std::exception& e) {
91731       {
91732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91733       };
91734     } catch (Dali::DaliException e) {
91735       {
91736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91737       };
91738     } catch (...) {
91739       {
91740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91741       };
91742     }
91743   }
91744
91745   jresult = result;
91746   return jresult;
91747 }
91748
91749
91750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91751   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91752   Dali::Property::Map *arg2 = 0 ;
91753
91754   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91755   arg2 = (Dali::Property::Map *)jarg2;
91756   if (!arg2) {
91757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91758     return ;
91759   }
91760   {
91761     try {
91762       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91763     } catch (std::out_of_range& e) {
91764       {
91765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91766       };
91767     } catch (std::exception& e) {
91768       {
91769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91770       };
91771     } catch (Dali::DaliException e) {
91772       {
91773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91774       };
91775     } catch (...) {
91776       {
91777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91778       };
91779     }
91780   }
91781
91782 }
91783
91784
91785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91786   void * jresult ;
91787   Dali::Toolkit::VisualFactory result;
91788
91789   {
91790     try {
91791       result = Dali::Toolkit::VisualFactory::Get();
91792     } catch (std::out_of_range& e) {
91793       {
91794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91795       };
91796     } catch (std::exception& e) {
91797       {
91798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91799       };
91800     } catch (Dali::DaliException e) {
91801       {
91802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91803       };
91804     } catch (...) {
91805       {
91806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91807       };
91808     }
91809   }
91810
91811   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91812   return jresult;
91813 }
91814
91815
91816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91817   void * jresult ;
91818   Dali::Toolkit::VisualFactory *result = 0 ;
91819
91820   {
91821     try {
91822       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91823     } catch (std::out_of_range& e) {
91824       {
91825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91826       };
91827     } catch (std::exception& e) {
91828       {
91829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91830       };
91831     } catch (Dali::DaliException e) {
91832       {
91833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91834       };
91835     } catch (...) {
91836       {
91837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91838       };
91839     }
91840   }
91841
91842   jresult = (void *)result;
91843   return jresult;
91844 }
91845
91846
91847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91848   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91849
91850   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91851   {
91852     try {
91853       delete arg1;
91854     } catch (std::out_of_range& e) {
91855       {
91856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91857       };
91858     } catch (std::exception& e) {
91859       {
91860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91861       };
91862     } catch (Dali::DaliException e) {
91863       {
91864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91865       };
91866     } catch (...) {
91867       {
91868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91869       };
91870     }
91871   }
91872
91873 }
91874
91875
91876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91877   void * jresult ;
91878   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91879   Dali::Toolkit::VisualFactory *result = 0 ;
91880
91881   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91882   if (!arg1) {
91883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91884     return 0;
91885   }
91886   {
91887     try {
91888       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91889     } catch (std::out_of_range& e) {
91890       {
91891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91892       };
91893     } catch (std::exception& e) {
91894       {
91895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91896       };
91897     } catch (Dali::DaliException e) {
91898       {
91899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91900       };
91901     } catch (...) {
91902       {
91903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91904       };
91905     }
91906   }
91907
91908   jresult = (void *)result;
91909   return jresult;
91910 }
91911
91912
91913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91914   void * jresult ;
91915   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91916   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91917   Dali::Toolkit::VisualFactory *result = 0 ;
91918
91919   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91920   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91921   if (!arg2) {
91922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91923     return 0;
91924   }
91925   {
91926     try {
91927       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91928     } catch (std::out_of_range& e) {
91929       {
91930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91931       };
91932     } catch (std::exception& e) {
91933       {
91934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91935       };
91936     } catch (Dali::DaliException e) {
91937       {
91938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91939       };
91940     } catch (...) {
91941       {
91942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91943       };
91944     }
91945   }
91946
91947   jresult = (void *)result;
91948   return jresult;
91949 }
91950
91951
91952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91953   void * jresult ;
91954   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91955   Dali::Property::Map *arg2 = 0 ;
91956   Dali::Toolkit::Visual::Base result;
91957
91958   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91959   arg2 = (Dali::Property::Map *)jarg2;
91960   if (!arg2) {
91961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91962     return 0;
91963   }
91964   {
91965     try {
91966       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91967     } catch (std::out_of_range& e) {
91968       {
91969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91970       };
91971     } catch (std::exception& e) {
91972       {
91973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91974       };
91975     } catch (Dali::DaliException e) {
91976       {
91977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91978       };
91979     } catch (...) {
91980       {
91981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91982       };
91983     }
91984   }
91985
91986   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91987   return jresult;
91988 }
91989
91990
91991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91992   void * jresult ;
91993   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91994   Dali::Image *arg2 = 0 ;
91995   Dali::Toolkit::Visual::Base result;
91996
91997   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91998   arg2 = (Dali::Image *)jarg2;
91999   if (!arg2) {
92000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
92001     return 0;
92002   }
92003   {
92004     try {
92005       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
92006     } catch (std::out_of_range& e) {
92007       {
92008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92009       };
92010     } catch (std::exception& e) {
92011       {
92012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92013       };
92014     } catch (Dali::DaliException e) {
92015       {
92016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92017       };
92018     } catch (...) {
92019       {
92020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92021       };
92022     }
92023   }
92024
92025   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92026   return jresult;
92027 }
92028
92029
92030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
92031   void * jresult ;
92032   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92033   std::string *arg2 = 0 ;
92034   Dali::ImageDimensions arg3 ;
92035   Dali::ImageDimensions *argp3 ;
92036   Dali::Toolkit::Visual::Base result;
92037
92038   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92039   if (!jarg2) {
92040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92041     return 0;
92042   }
92043   std::string arg2_str(jarg2);
92044   arg2 = &arg2_str;
92045   argp3 = (Dali::ImageDimensions *)jarg3;
92046   if (!argp3) {
92047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92048     return 0;
92049   }
92050   arg3 = *argp3;
92051   {
92052     try {
92053       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
92054     } catch (std::out_of_range& e) {
92055       {
92056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92057       };
92058     } catch (std::exception& e) {
92059       {
92060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92061       };
92062     } catch (Dali::DaliException e) {
92063       {
92064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92065       };
92066     } catch (...) {
92067       {
92068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92069       };
92070     }
92071   }
92072
92073   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92074
92075   //argout typemap for const std::string&
92076
92077   return jresult;
92078 }
92079
92080
92081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92082   void * jresult ;
92083   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92084
92085   {
92086     try {
92087       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92088     } catch (std::out_of_range& e) {
92089       {
92090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92091       };
92092     } catch (std::exception& e) {
92093       {
92094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92095       };
92096     } catch (Dali::DaliException e) {
92097       {
92098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92099       };
92100     } catch (...) {
92101       {
92102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92103       };
92104     }
92105   }
92106
92107   jresult = (void *)result;
92108   return jresult;
92109 }
92110
92111
92112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92113   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92114
92115   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92116   {
92117     try {
92118       delete arg1;
92119     } catch (std::out_of_range& e) {
92120       {
92121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92122       };
92123     } catch (std::exception& e) {
92124       {
92125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92126       };
92127     } catch (Dali::DaliException e) {
92128       {
92129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92130       };
92131     } catch (...) {
92132       {
92133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92134       };
92135     }
92136   }
92137
92138 }
92139
92140
92141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92142   void * jresult ;
92143   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92144   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92145
92146   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92147   if (!arg1) {
92148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92149     return 0;
92150   }
92151   {
92152     try {
92153       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
92154     } catch (std::out_of_range& e) {
92155       {
92156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92157       };
92158     } catch (std::exception& e) {
92159       {
92160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92161       };
92162     } catch (Dali::DaliException e) {
92163       {
92164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92165       };
92166     } catch (...) {
92167       {
92168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92169       };
92170     }
92171   }
92172
92173   jresult = (void *)result;
92174   return jresult;
92175 }
92176
92177
92178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92179   void * jresult ;
92180   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92181   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92182   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92183
92184   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92185   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92186   if (!arg2) {
92187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92188     return 0;
92189   }
92190   {
92191     try {
92192       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92193     } catch (std::out_of_range& e) {
92194       {
92195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92196       };
92197     } catch (std::exception& e) {
92198       {
92199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92200       };
92201     } catch (Dali::DaliException e) {
92202       {
92203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92204       };
92205     } catch (...) {
92206       {
92207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92208       };
92209     }
92210   }
92211
92212   jresult = (void *)result;
92213   return jresult;
92214 }
92215
92216
92217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92218   void * jresult ;
92219   Dali::Toolkit::AsyncImageLoader result;
92220
92221   {
92222     try {
92223       result = Dali::Toolkit::AsyncImageLoader::New();
92224     } catch (std::out_of_range& e) {
92225       {
92226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92227       };
92228     } catch (std::exception& e) {
92229       {
92230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92231       };
92232     } catch (Dali::DaliException e) {
92233       {
92234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92235       };
92236     } catch (...) {
92237       {
92238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92239       };
92240     }
92241   }
92242
92243   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92244   return jresult;
92245 }
92246
92247
92248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92249   void * jresult ;
92250   Dali::BaseHandle arg1 ;
92251   Dali::BaseHandle *argp1 ;
92252   Dali::Toolkit::AsyncImageLoader result;
92253
92254   argp1 = (Dali::BaseHandle *)jarg1;
92255   if (!argp1) {
92256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92257     return 0;
92258   }
92259   arg1 = *argp1;
92260   {
92261     try {
92262       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92263     } catch (std::out_of_range& e) {
92264       {
92265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92266       };
92267     } catch (std::exception& e) {
92268       {
92269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92270       };
92271     } catch (Dali::DaliException e) {
92272       {
92273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92274       };
92275     } catch (...) {
92276       {
92277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92278       };
92279     }
92280   }
92281
92282   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92283   return jresult;
92284 }
92285
92286
92287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92288   unsigned int jresult ;
92289   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92290   std::string *arg2 = 0 ;
92291   uint32_t result;
92292
92293   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92294   if (!jarg2) {
92295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92296     return 0;
92297   }
92298   std::string arg2_str(jarg2);
92299   arg2 = &arg2_str;
92300   {
92301     try {
92302       result = (arg1)->Load((std::string const &)*arg2);
92303     } catch (std::out_of_range& e) {
92304       {
92305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92306       };
92307     } catch (std::exception& e) {
92308       {
92309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92310       };
92311     } catch (Dali::DaliException e) {
92312       {
92313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92314       };
92315     } catch (...) {
92316       {
92317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92318       };
92319     }
92320   }
92321
92322   jresult = result;
92323
92324   //argout typemap for const std::string&
92325
92326   return jresult;
92327 }
92328
92329
92330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92331   unsigned int jresult ;
92332   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92333   std::string *arg2 = 0 ;
92334   Dali::ImageDimensions arg3 ;
92335   Dali::ImageDimensions *argp3 ;
92336   uint32_t result;
92337
92338   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92339   if (!jarg2) {
92340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92341     return 0;
92342   }
92343   std::string arg2_str(jarg2);
92344   arg2 = &arg2_str;
92345   argp3 = (Dali::ImageDimensions *)jarg3;
92346   if (!argp3) {
92347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92348     return 0;
92349   }
92350   arg3 = *argp3;
92351   {
92352     try {
92353       result = (arg1)->Load((std::string const &)*arg2,arg3);
92354     } catch (std::out_of_range& e) {
92355       {
92356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92357       };
92358     } catch (std::exception& e) {
92359       {
92360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92361       };
92362     } catch (Dali::DaliException e) {
92363       {
92364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92365       };
92366     } catch (...) {
92367       {
92368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92369       };
92370     }
92371   }
92372
92373   jresult = result;
92374
92375   //argout typemap for const std::string&
92376
92377   return jresult;
92378 }
92379
92380
92381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92382   unsigned int jresult ;
92383   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92384   std::string *arg2 = 0 ;
92385   Dali::ImageDimensions arg3 ;
92386   Dali::FittingMode::Type arg4 ;
92387   Dali::SamplingMode::Type arg5 ;
92388   bool arg6 ;
92389   Dali::ImageDimensions *argp3 ;
92390   uint32_t result;
92391
92392   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92393   if (!jarg2) {
92394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92395     return 0;
92396   }
92397   std::string arg2_str(jarg2);
92398   arg2 = &arg2_str;
92399   argp3 = (Dali::ImageDimensions *)jarg3;
92400   if (!argp3) {
92401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92402     return 0;
92403   }
92404   arg3 = *argp3;
92405   arg4 = (Dali::FittingMode::Type)jarg4;
92406   arg5 = (Dali::SamplingMode::Type)jarg5;
92407   arg6 = jarg6 ? true : false;
92408   {
92409     try {
92410       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92411     } catch (std::out_of_range& e) {
92412       {
92413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92414       };
92415     } catch (std::exception& e) {
92416       {
92417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92418       };
92419     } catch (Dali::DaliException e) {
92420       {
92421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92422       };
92423     } catch (...) {
92424       {
92425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92426       };
92427     }
92428   }
92429
92430   jresult = result;
92431
92432   //argout typemap for const std::string&
92433
92434   return jresult;
92435 }
92436
92437
92438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92439   unsigned int jresult ;
92440   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92441   uint32_t arg2 ;
92442   bool result;
92443
92444   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92445   arg2 = (uint32_t)jarg2;
92446   {
92447     try {
92448       result = (bool)(arg1)->Cancel(arg2);
92449     } catch (std::out_of_range& e) {
92450       {
92451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92452       };
92453     } catch (std::exception& e) {
92454       {
92455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92456       };
92457     } catch (Dali::DaliException e) {
92458       {
92459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92460       };
92461     } catch (...) {
92462       {
92463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92464       };
92465     }
92466   }
92467
92468   jresult = result;
92469   return jresult;
92470 }
92471
92472
92473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92474   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92475
92476   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92477   {
92478     try {
92479       (arg1)->CancelAll();
92480     } catch (std::out_of_range& e) {
92481       {
92482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92483       };
92484     } catch (std::exception& e) {
92485       {
92486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92487       };
92488     } catch (Dali::DaliException e) {
92489       {
92490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92491       };
92492     } catch (...) {
92493       {
92494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92495       };
92496     }
92497   }
92498
92499 }
92500
92501
92502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92503   void * jresult ;
92504   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92505   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92506
92507   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92508   {
92509     try {
92510       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92511     } catch (std::out_of_range& e) {
92512       {
92513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92514       };
92515     } catch (std::exception& e) {
92516       {
92517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92518       };
92519     } catch (Dali::DaliException e) {
92520       {
92521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92522       };
92523     } catch (...) {
92524       {
92525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92526       };
92527     }
92528   }
92529
92530   jresult = (void *)result;
92531   return jresult;
92532 }
92533
92534
92535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92536   void * jresult ;
92537   std::string *arg1 = 0 ;
92538   Dali::PixelData result;
92539
92540   if (!jarg1) {
92541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92542     return 0;
92543   }
92544   std::string arg1_str(jarg1);
92545   arg1 = &arg1_str;
92546   {
92547     try {
92548       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92549     } catch (std::out_of_range& e) {
92550       {
92551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92552       };
92553     } catch (std::exception& e) {
92554       {
92555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92556       };
92557     } catch (Dali::DaliException e) {
92558       {
92559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92560       };
92561     } catch (...) {
92562       {
92563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92564       };
92565     }
92566   }
92567
92568   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92569
92570   //argout typemap for const std::string&
92571
92572   return jresult;
92573 }
92574
92575
92576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92577   void * jresult ;
92578   std::string *arg1 = 0 ;
92579   Dali::ImageDimensions arg2 ;
92580   Dali::ImageDimensions *argp2 ;
92581   Dali::PixelData result;
92582
92583   if (!jarg1) {
92584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92585     return 0;
92586   }
92587   std::string arg1_str(jarg1);
92588   arg1 = &arg1_str;
92589   argp2 = (Dali::ImageDimensions *)jarg2;
92590   if (!argp2) {
92591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92592     return 0;
92593   }
92594   arg2 = *argp2;
92595   {
92596     try {
92597       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92598     } catch (std::out_of_range& e) {
92599       {
92600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92601       };
92602     } catch (std::exception& e) {
92603       {
92604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92605       };
92606     } catch (Dali::DaliException e) {
92607       {
92608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92609       };
92610     } catch (...) {
92611       {
92612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92613       };
92614     }
92615   }
92616
92617   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92618
92619   //argout typemap for const std::string&
92620
92621   return jresult;
92622 }
92623
92624
92625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92626   void * jresult ;
92627   std::string *arg1 = 0 ;
92628   Dali::ImageDimensions arg2 ;
92629   Dali::FittingMode::Type arg3 ;
92630   Dali::SamplingMode::Type arg4 ;
92631   bool arg5 ;
92632   Dali::ImageDimensions *argp2 ;
92633   Dali::PixelData result;
92634
92635   if (!jarg1) {
92636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92637     return 0;
92638   }
92639   std::string arg1_str(jarg1);
92640   arg1 = &arg1_str;
92641   argp2 = (Dali::ImageDimensions *)jarg2;
92642   if (!argp2) {
92643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92644     return 0;
92645   }
92646   arg2 = *argp2;
92647   arg3 = (Dali::FittingMode::Type)jarg3;
92648   arg4 = (Dali::SamplingMode::Type)jarg4;
92649   arg5 = jarg5 ? true : false;
92650   {
92651     try {
92652       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92653     } catch (std::out_of_range& e) {
92654       {
92655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92656       };
92657     } catch (std::exception& e) {
92658       {
92659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92660       };
92661     } catch (Dali::DaliException e) {
92662       {
92663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92664       };
92665     } catch (...) {
92666       {
92667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92668       };
92669     }
92670   }
92671
92672   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92673
92674   //argout typemap for const std::string&
92675
92676   return jresult;
92677 }
92678
92679
92680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92681   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92682
92683   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92684   {
92685     try {
92686       delete arg1;
92687     } catch (std::out_of_range& e) {
92688       {
92689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92690       };
92691     } catch (std::exception& e) {
92692       {
92693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92694       };
92695     } catch (Dali::DaliException e) {
92696       {
92697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92698       };
92699     } catch (...) {
92700       {
92701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92702       };
92703     }
92704   }
92705
92706 }
92707
92708
92709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92710   void * jresult ;
92711   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92712   Dali::Actor arg2 ;
92713   Dali::Actor arg3 ;
92714   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92715   Dali::Actor *argp2 ;
92716   Dali::Actor *argp3 ;
92717   Dali::Actor result;
92718
92719   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92720   argp2 = (Dali::Actor *)jarg2;
92721   if (!argp2) {
92722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92723     return 0;
92724   }
92725   arg2 = *argp2;
92726   argp3 = (Dali::Actor *)jarg3;
92727   if (!argp3) {
92728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92729     return 0;
92730   }
92731   arg3 = *argp3;
92732   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92733   {
92734     try {
92735       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92736     } catch (std::out_of_range& e) {
92737       {
92738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92739       };
92740     } catch (std::exception& e) {
92741       {
92742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92743       };
92744     } catch (Dali::DaliException e) {
92745       {
92746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92747       };
92748     } catch (...) {
92749       {
92750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92751       };
92752     }
92753   }
92754
92755   jresult = new Dali::Actor((const Dali::Actor &)result);
92756   return jresult;
92757 }
92758
92759
92760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92761   void * jresult ;
92762   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92763
92764   {
92765     try {
92766       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92767     } catch (std::out_of_range& e) {
92768       {
92769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92770       };
92771     } catch (std::exception& e) {
92772       {
92773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92774       };
92775     } catch (Dali::DaliException e) {
92776       {
92777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92778       };
92779     } catch (...) {
92780       {
92781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92782       };
92783     }
92784   }
92785
92786   jresult = (void *)result;
92787   return jresult;
92788 }
92789
92790
92791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92792   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92793   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92794   if (director) {
92795     director->swig_connect_director(callback0);
92796   }
92797 }
92798
92799
92800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92801   KeyboardFocusManager arg1 ;
92802   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92803   KeyboardFocusManager *argp1 ;
92804
92805   argp1 = (KeyboardFocusManager *)jarg1;
92806   if (!argp1) {
92807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92808     return ;
92809   }
92810   arg1 = *argp1;
92811   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92812   if (!arg2) {
92813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92814     return ;
92815   }
92816   {
92817     try {
92818       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92819     } catch (std::out_of_range& e) {
92820       {
92821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92822       };
92823     } catch (std::exception& e) {
92824       {
92825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92826       };
92827     } catch (Dali::DaliException e) {
92828       {
92829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92830       };
92831     } catch (...) {
92832       {
92833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92834       };
92835     }
92836   }
92837
92838 }
92839
92840
92841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92842   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92843
92844   arg1 = (std::vector< unsigned int > *)jarg1;
92845   {
92846     try {
92847       (arg1)->clear();
92848     } catch (std::out_of_range& e) {
92849       {
92850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92851       };
92852     } catch (std::exception& e) {
92853       {
92854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92855       };
92856     } catch (Dali::DaliException e) {
92857       {
92858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92859       };
92860     } catch (...) {
92861       {
92862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92863       };
92864     }
92865   }
92866
92867 }
92868
92869
92870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92871   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92872   unsigned int *arg2 = 0 ;
92873   unsigned int temp2 ;
92874
92875   arg1 = (std::vector< unsigned int > *)jarg1;
92876   temp2 = (unsigned int)jarg2;
92877   arg2 = &temp2;
92878   {
92879     try {
92880       (arg1)->push_back((unsigned int const &)*arg2);
92881     } catch (std::out_of_range& e) {
92882       {
92883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92884       };
92885     } catch (std::exception& e) {
92886       {
92887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92888       };
92889     } catch (Dali::DaliException e) {
92890       {
92891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92892       };
92893     } catch (...) {
92894       {
92895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92896       };
92897     }
92898   }
92899
92900 }
92901
92902
92903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92904   unsigned long jresult ;
92905   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92906   std::vector< unsigned int >::size_type result;
92907
92908   arg1 = (std::vector< unsigned int > *)jarg1;
92909   {
92910     try {
92911       result = ((std::vector< unsigned int > const *)arg1)->size();
92912     } catch (std::out_of_range& e) {
92913       {
92914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92915       };
92916     } catch (std::exception& e) {
92917       {
92918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92919       };
92920     } catch (Dali::DaliException e) {
92921       {
92922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92923       };
92924     } catch (...) {
92925       {
92926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92927       };
92928     }
92929   }
92930
92931   jresult = (unsigned long)result;
92932   return jresult;
92933 }
92934
92935
92936 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92937   unsigned long jresult ;
92938   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92939   std::vector< unsigned int >::size_type result;
92940
92941   arg1 = (std::vector< unsigned int > *)jarg1;
92942   {
92943     try {
92944       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92945     } catch (std::out_of_range& e) {
92946       {
92947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92948       };
92949     } catch (std::exception& e) {
92950       {
92951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92952       };
92953     } catch (Dali::DaliException e) {
92954       {
92955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92956       };
92957     } catch (...) {
92958       {
92959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92960       };
92961     }
92962   }
92963
92964   jresult = (unsigned long)result;
92965   return jresult;
92966 }
92967
92968
92969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92970   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92971   std::vector< unsigned int >::size_type arg2 ;
92972
92973   arg1 = (std::vector< unsigned int > *)jarg1;
92974   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92975   {
92976     try {
92977       (arg1)->reserve(arg2);
92978     } catch (std::out_of_range& e) {
92979       {
92980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92981       };
92982     } catch (std::exception& e) {
92983       {
92984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92985       };
92986     } catch (Dali::DaliException e) {
92987       {
92988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92989       };
92990     } catch (...) {
92991       {
92992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92993       };
92994     }
92995   }
92996
92997 }
92998
92999
93000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
93001   void * jresult ;
93002   std::vector< unsigned int > *result = 0 ;
93003
93004   {
93005     try {
93006       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
93007     } catch (std::out_of_range& e) {
93008       {
93009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93010       };
93011     } catch (std::exception& e) {
93012       {
93013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93014       };
93015     } catch (Dali::DaliException e) {
93016       {
93017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93018       };
93019     } catch (...) {
93020       {
93021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93022       };
93023     }
93024   }
93025
93026   jresult = (void *)result;
93027   return jresult;
93028 }
93029
93030
93031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
93032   void * jresult ;
93033   std::vector< unsigned int > *arg1 = 0 ;
93034   std::vector< unsigned int > *result = 0 ;
93035
93036   arg1 = (std::vector< unsigned int > *)jarg1;
93037   if (!arg1) {
93038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93039     return 0;
93040   }
93041   {
93042     try {
93043       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
93044     } catch (std::out_of_range& e) {
93045       {
93046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93047       };
93048     } catch (std::exception& e) {
93049       {
93050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93051       };
93052     } catch (Dali::DaliException e) {
93053       {
93054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93055       };
93056     } catch (...) {
93057       {
93058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93059       };
93060     }
93061   }
93062
93063   jresult = (void *)result;
93064   return jresult;
93065 }
93066
93067
93068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
93069   void * jresult ;
93070   int arg1 ;
93071   std::vector< unsigned int > *result = 0 ;
93072
93073   arg1 = (int)jarg1;
93074   {
93075     try {
93076       try {
93077         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93078       }
93079       catch(std::out_of_range &_e) {
93080         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93081         return 0;
93082       }
93083
93084     } catch (std::out_of_range& e) {
93085       {
93086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93087       };
93088     } catch (std::exception& e) {
93089       {
93090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93091       };
93092     } catch (Dali::DaliException e) {
93093       {
93094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93095       };
93096     } catch (...) {
93097       {
93098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93099       };
93100     }
93101   }
93102
93103   jresult = (void *)result;
93104   return jresult;
93105 }
93106
93107
93108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93109   unsigned int jresult ;
93110   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93111   int arg2 ;
93112   unsigned int result;
93113
93114   arg1 = (std::vector< unsigned int > *)jarg1;
93115   arg2 = (int)jarg2;
93116   {
93117     try {
93118       try {
93119         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93120       }
93121       catch(std::out_of_range &_e) {
93122         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93123         return 0;
93124       }
93125
93126     } catch (std::out_of_range& e) {
93127       {
93128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93129       };
93130     } catch (std::exception& e) {
93131       {
93132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93133       };
93134     } catch (Dali::DaliException e) {
93135       {
93136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93137       };
93138     } catch (...) {
93139       {
93140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93141       };
93142     }
93143   }
93144
93145   jresult = result;
93146   return jresult;
93147 }
93148
93149
93150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93151   unsigned int jresult ;
93152   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93153   int arg2 ;
93154   unsigned int *result = 0 ;
93155
93156   arg1 = (std::vector< unsigned int > *)jarg1;
93157   arg2 = (int)jarg2;
93158   {
93159     try {
93160       try {
93161         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93162       }
93163       catch(std::out_of_range &_e) {
93164         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93165         return 0;
93166       }
93167
93168     } catch (std::out_of_range& e) {
93169       {
93170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93171       };
93172     } catch (std::exception& e) {
93173       {
93174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93175       };
93176     } catch (Dali::DaliException e) {
93177       {
93178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93179       };
93180     } catch (...) {
93181       {
93182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93183       };
93184     }
93185   }
93186
93187   jresult = *result;
93188   return jresult;
93189 }
93190
93191
93192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93193   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93194   int arg2 ;
93195   unsigned int *arg3 = 0 ;
93196   unsigned int temp3 ;
93197
93198   arg1 = (std::vector< unsigned int > *)jarg1;
93199   arg2 = (int)jarg2;
93200   temp3 = (unsigned int)jarg3;
93201   arg3 = &temp3;
93202   {
93203     try {
93204       try {
93205         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93206       }
93207       catch(std::out_of_range &_e) {
93208         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93209         return ;
93210       }
93211
93212     } catch (std::out_of_range& e) {
93213       {
93214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93215       };
93216     } catch (std::exception& e) {
93217       {
93218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93219       };
93220     } catch (Dali::DaliException e) {
93221       {
93222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93223       };
93224     } catch (...) {
93225       {
93226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93227       };
93228     }
93229   }
93230
93231 }
93232
93233
93234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93235   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93236   std::vector< unsigned int > *arg2 = 0 ;
93237
93238   arg1 = (std::vector< unsigned int > *)jarg1;
93239   arg2 = (std::vector< unsigned int > *)jarg2;
93240   if (!arg2) {
93241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93242     return ;
93243   }
93244   {
93245     try {
93246       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93247     } catch (std::out_of_range& e) {
93248       {
93249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93250       };
93251     } catch (std::exception& e) {
93252       {
93253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93254       };
93255     } catch (Dali::DaliException e) {
93256       {
93257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93258       };
93259     } catch (...) {
93260       {
93261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93262       };
93263     }
93264   }
93265
93266 }
93267
93268
93269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93270   void * jresult ;
93271   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93272   int arg2 ;
93273   int arg3 ;
93274   std::vector< unsigned int > *result = 0 ;
93275
93276   arg1 = (std::vector< unsigned int > *)jarg1;
93277   arg2 = (int)jarg2;
93278   arg3 = (int)jarg3;
93279   {
93280     try {
93281       try {
93282         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93283       }
93284       catch(std::out_of_range &_e) {
93285         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93286         return 0;
93287       }
93288       catch(std::invalid_argument &_e) {
93289         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93290         return 0;
93291       }
93292
93293     } catch (std::out_of_range& e) {
93294       {
93295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93296       };
93297     } catch (std::exception& e) {
93298       {
93299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93300       };
93301     } catch (Dali::DaliException e) {
93302       {
93303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93304       };
93305     } catch (...) {
93306       {
93307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93308       };
93309     }
93310   }
93311
93312   jresult = (void *)result;
93313   return jresult;
93314 }
93315
93316
93317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93318   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93319   int arg2 ;
93320   unsigned int *arg3 = 0 ;
93321   unsigned int temp3 ;
93322
93323   arg1 = (std::vector< unsigned int > *)jarg1;
93324   arg2 = (int)jarg2;
93325   temp3 = (unsigned int)jarg3;
93326   arg3 = &temp3;
93327   {
93328     try {
93329       try {
93330         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93331       }
93332       catch(std::out_of_range &_e) {
93333         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93334         return ;
93335       }
93336
93337     } catch (std::out_of_range& e) {
93338       {
93339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93340       };
93341     } catch (std::exception& e) {
93342       {
93343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93344       };
93345     } catch (Dali::DaliException e) {
93346       {
93347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93348       };
93349     } catch (...) {
93350       {
93351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93352       };
93353     }
93354   }
93355
93356 }
93357
93358
93359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93360   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93361   int arg2 ;
93362   std::vector< unsigned int > *arg3 = 0 ;
93363
93364   arg1 = (std::vector< unsigned int > *)jarg1;
93365   arg2 = (int)jarg2;
93366   arg3 = (std::vector< unsigned int > *)jarg3;
93367   if (!arg3) {
93368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93369     return ;
93370   }
93371   {
93372     try {
93373       try {
93374         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93375       }
93376       catch(std::out_of_range &_e) {
93377         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93378         return ;
93379       }
93380
93381     } catch (std::out_of_range& e) {
93382       {
93383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93384       };
93385     } catch (std::exception& e) {
93386       {
93387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93388       };
93389     } catch (Dali::DaliException e) {
93390       {
93391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93392       };
93393     } catch (...) {
93394       {
93395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93396       };
93397     }
93398   }
93399
93400 }
93401
93402
93403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93404   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93405   int arg2 ;
93406
93407   arg1 = (std::vector< unsigned int > *)jarg1;
93408   arg2 = (int)jarg2;
93409   {
93410     try {
93411       try {
93412         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93413       }
93414       catch(std::out_of_range &_e) {
93415         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93416         return ;
93417       }
93418
93419     } catch (std::out_of_range& e) {
93420       {
93421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93422       };
93423     } catch (std::exception& e) {
93424       {
93425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93426       };
93427     } catch (Dali::DaliException e) {
93428       {
93429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93430       };
93431     } catch (...) {
93432       {
93433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93434       };
93435     }
93436   }
93437
93438 }
93439
93440
93441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93442   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93443   int arg2 ;
93444   int arg3 ;
93445
93446   arg1 = (std::vector< unsigned int > *)jarg1;
93447   arg2 = (int)jarg2;
93448   arg3 = (int)jarg3;
93449   {
93450     try {
93451       try {
93452         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93453       }
93454       catch(std::out_of_range &_e) {
93455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93456         return ;
93457       }
93458       catch(std::invalid_argument &_e) {
93459         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93460         return ;
93461       }
93462
93463     } catch (std::out_of_range& e) {
93464       {
93465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93466       };
93467     } catch (std::exception& e) {
93468       {
93469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93470       };
93471     } catch (Dali::DaliException e) {
93472       {
93473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93474       };
93475     } catch (...) {
93476       {
93477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93478       };
93479     }
93480   }
93481
93482 }
93483
93484
93485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93486   void * jresult ;
93487   unsigned int *arg1 = 0 ;
93488   int arg2 ;
93489   unsigned int temp1 ;
93490   std::vector< unsigned int > *result = 0 ;
93491
93492   temp1 = (unsigned int)jarg1;
93493   arg1 = &temp1;
93494   arg2 = (int)jarg2;
93495   {
93496     try {
93497       try {
93498         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93499       }
93500       catch(std::out_of_range &_e) {
93501         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93502         return 0;
93503       }
93504
93505     } catch (std::out_of_range& e) {
93506       {
93507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93508       };
93509     } catch (std::exception& e) {
93510       {
93511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93512       };
93513     } catch (Dali::DaliException e) {
93514       {
93515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93516       };
93517     } catch (...) {
93518       {
93519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93520       };
93521     }
93522   }
93523
93524   jresult = (void *)result;
93525   return jresult;
93526 }
93527
93528
93529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93530   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93531
93532   arg1 = (std::vector< unsigned int > *)jarg1;
93533   {
93534     try {
93535       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93536     } catch (std::out_of_range& e) {
93537       {
93538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93539       };
93540     } catch (std::exception& e) {
93541       {
93542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93543       };
93544     } catch (Dali::DaliException e) {
93545       {
93546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93547       };
93548     } catch (...) {
93549       {
93550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93551       };
93552     }
93553   }
93554
93555 }
93556
93557
93558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93559   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93560   int arg2 ;
93561   int arg3 ;
93562
93563   arg1 = (std::vector< unsigned int > *)jarg1;
93564   arg2 = (int)jarg2;
93565   arg3 = (int)jarg3;
93566   {
93567     try {
93568       try {
93569         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93570       }
93571       catch(std::out_of_range &_e) {
93572         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93573         return ;
93574       }
93575       catch(std::invalid_argument &_e) {
93576         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93577         return ;
93578       }
93579
93580     } catch (std::out_of_range& e) {
93581       {
93582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93583       };
93584     } catch (std::exception& e) {
93585       {
93586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93587       };
93588     } catch (Dali::DaliException e) {
93589       {
93590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93591       };
93592     } catch (...) {
93593       {
93594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93595       };
93596     }
93597   }
93598
93599 }
93600
93601
93602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93603   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93604   int arg2 ;
93605   std::vector< unsigned int > *arg3 = 0 ;
93606
93607   arg1 = (std::vector< unsigned int > *)jarg1;
93608   arg2 = (int)jarg2;
93609   arg3 = (std::vector< unsigned int > *)jarg3;
93610   if (!arg3) {
93611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93612     return ;
93613   }
93614   {
93615     try {
93616       try {
93617         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93618       }
93619       catch(std::out_of_range &_e) {
93620         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93621         return ;
93622       }
93623
93624     } catch (std::out_of_range& e) {
93625       {
93626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93627       };
93628     } catch (std::exception& e) {
93629       {
93630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93631       };
93632     } catch (Dali::DaliException e) {
93633       {
93634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93635       };
93636     } catch (...) {
93637       {
93638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93639       };
93640     }
93641   }
93642
93643 }
93644
93645
93646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93647   unsigned int jresult ;
93648   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93649   unsigned int *arg2 = 0 ;
93650   unsigned int temp2 ;
93651   bool result;
93652
93653   arg1 = (std::vector< unsigned int > *)jarg1;
93654   temp2 = (unsigned int)jarg2;
93655   arg2 = &temp2;
93656   {
93657     try {
93658       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93659     } catch (std::out_of_range& e) {
93660       {
93661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93662       };
93663     } catch (std::exception& e) {
93664       {
93665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93666       };
93667     } catch (Dali::DaliException e) {
93668       {
93669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93670       };
93671     } catch (...) {
93672       {
93673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93674       };
93675     }
93676   }
93677
93678   jresult = result;
93679   return jresult;
93680 }
93681
93682
93683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93684   int jresult ;
93685   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93686   unsigned int *arg2 = 0 ;
93687   unsigned int temp2 ;
93688   int result;
93689
93690   arg1 = (std::vector< unsigned int > *)jarg1;
93691   temp2 = (unsigned int)jarg2;
93692   arg2 = &temp2;
93693   {
93694     try {
93695       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93696     } catch (std::out_of_range& e) {
93697       {
93698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93699       };
93700     } catch (std::exception& e) {
93701       {
93702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93703       };
93704     } catch (Dali::DaliException e) {
93705       {
93706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93707       };
93708     } catch (...) {
93709       {
93710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93711       };
93712     }
93713   }
93714
93715   jresult = result;
93716   return jresult;
93717 }
93718
93719
93720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93721   int jresult ;
93722   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93723   unsigned int *arg2 = 0 ;
93724   unsigned int temp2 ;
93725   int result;
93726
93727   arg1 = (std::vector< unsigned int > *)jarg1;
93728   temp2 = (unsigned int)jarg2;
93729   arg2 = &temp2;
93730   {
93731     try {
93732       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93733     } catch (std::out_of_range& e) {
93734       {
93735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93736       };
93737     } catch (std::exception& e) {
93738       {
93739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93740       };
93741     } catch (Dali::DaliException e) {
93742       {
93743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93744       };
93745     } catch (...) {
93746       {
93747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93748       };
93749     }
93750   }
93751
93752   jresult = result;
93753   return jresult;
93754 }
93755
93756
93757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93758   unsigned int jresult ;
93759   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93760   unsigned int *arg2 = 0 ;
93761   unsigned int temp2 ;
93762   bool result;
93763
93764   arg1 = (std::vector< unsigned int > *)jarg1;
93765   temp2 = (unsigned int)jarg2;
93766   arg2 = &temp2;
93767   {
93768     try {
93769       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93770     } catch (std::out_of_range& e) {
93771       {
93772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93773       };
93774     } catch (std::exception& e) {
93775       {
93776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93777       };
93778     } catch (Dali::DaliException e) {
93779       {
93780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93781       };
93782     } catch (...) {
93783       {
93784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93785       };
93786     }
93787   }
93788
93789   jresult = result;
93790   return jresult;
93791 }
93792
93793
93794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93795   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93796
93797   arg1 = (std::vector< unsigned int > *)jarg1;
93798   {
93799     try {
93800       delete arg1;
93801     } catch (std::out_of_range& e) {
93802       {
93803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93804       };
93805     } catch (std::exception& e) {
93806       {
93807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93808       };
93809     } catch (Dali::DaliException e) {
93810       {
93811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93812       };
93813     } catch (...) {
93814       {
93815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93816       };
93817     }
93818   }
93819
93820 }
93821
93822
93823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93824   void * jresult ;
93825   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93826
93827   {
93828     try {
93829       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93830     } catch (std::out_of_range& e) {
93831       {
93832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93833       };
93834     } catch (std::exception& e) {
93835       {
93836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93837       };
93838     } catch (Dali::DaliException e) {
93839       {
93840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93841       };
93842     } catch (...) {
93843       {
93844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93845       };
93846     }
93847   }
93848
93849   jresult = (void *)result;
93850   return jresult;
93851 }
93852
93853
93854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93855   void * jresult ;
93856   unsigned int arg1 ;
93857   Dali::Actor arg2 ;
93858   Dali::Actor *argp2 ;
93859   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93860
93861   arg1 = (unsigned int)jarg1;
93862   argp2 = (Dali::Actor *)jarg2;
93863   if (!argp2) {
93864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93865     return 0;
93866   }
93867   arg2 = *argp2;
93868   {
93869     try {
93870       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93871     } catch (std::out_of_range& e) {
93872       {
93873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93874       };
93875     } catch (std::exception& e) {
93876       {
93877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93878       };
93879     } catch (Dali::DaliException e) {
93880       {
93881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93882       };
93883     } catch (...) {
93884       {
93885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93886       };
93887     }
93888   }
93889
93890   jresult = (void *)result;
93891   return jresult;
93892 }
93893
93894
93895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93896   void * jresult ;
93897   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93898   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93899
93900   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93901   if (!arg1) {
93902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93903     return 0;
93904   }
93905   {
93906     try {
93907       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93908     } catch (std::out_of_range& e) {
93909       {
93910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93911       };
93912     } catch (std::exception& e) {
93913       {
93914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93915       };
93916     } catch (Dali::DaliException e) {
93917       {
93918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93919       };
93920     } catch (...) {
93921       {
93922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93923       };
93924     }
93925   }
93926
93927   jresult = (void *)result;
93928   return jresult;
93929 }
93930
93931
93932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93933   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93934   unsigned int arg2 ;
93935
93936   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93937   arg2 = (unsigned int)jarg2;
93938   if (arg1) (arg1)->first = arg2;
93939 }
93940
93941
93942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93943   unsigned int jresult ;
93944   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93945   unsigned int result;
93946
93947   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93948   result = (unsigned int) ((arg1)->first);
93949   jresult = result;
93950   return jresult;
93951 }
93952
93953
93954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93955   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93956   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93957
93958   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93959   arg2 = (Dali::Actor *)jarg2;
93960   if (arg1) (arg1)->second = *arg2;
93961 }
93962
93963
93964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93965   void * jresult ;
93966   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93967   Dali::Actor *result = 0 ;
93968
93969   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93970   result = (Dali::Actor *)& ((arg1)->second);
93971   jresult = (void *)result;
93972   return jresult;
93973 }
93974
93975
93976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93977   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93978
93979   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93980   {
93981     try {
93982       delete arg1;
93983     } catch (std::out_of_range& e) {
93984       {
93985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93986       };
93987     } catch (std::exception& e) {
93988       {
93989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93990       };
93991     } catch (Dali::DaliException e) {
93992       {
93993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93994       };
93995     } catch (...) {
93996       {
93997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93998       };
93999     }
94000   }
94001
94002 }
94003
94004
94005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
94006   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94007
94008   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94009   {
94010     try {
94011       (arg1)->clear();
94012     } catch (std::out_of_range& e) {
94013       {
94014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94015       };
94016     } catch (std::exception& e) {
94017       {
94018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94019       };
94020     } catch (Dali::DaliException e) {
94021       {
94022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94023       };
94024     } catch (...) {
94025       {
94026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94027       };
94028     }
94029   }
94030
94031 }
94032
94033
94034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
94035   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94036   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
94037
94038   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94039   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
94040   if (!arg2) {
94041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94042     return ;
94043   }
94044   {
94045     try {
94046       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
94047     } catch (std::out_of_range& e) {
94048       {
94049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94050       };
94051     } catch (std::exception& e) {
94052       {
94053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94054       };
94055     } catch (Dali::DaliException e) {
94056       {
94057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94058       };
94059     } catch (...) {
94060       {
94061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94062       };
94063     }
94064   }
94065
94066 }
94067
94068
94069 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94070   unsigned long jresult ;
94071   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94072   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94073
94074   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94075   {
94076     try {
94077       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94078     } catch (std::out_of_range& e) {
94079       {
94080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94081       };
94082     } catch (std::exception& e) {
94083       {
94084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94085       };
94086     } catch (Dali::DaliException e) {
94087       {
94088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94089       };
94090     } catch (...) {
94091       {
94092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94093       };
94094     }
94095   }
94096
94097   jresult = (unsigned long)result;
94098   return jresult;
94099 }
94100
94101
94102 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94103   unsigned long jresult ;
94104   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94105   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94106
94107   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94108   {
94109     try {
94110       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
94111     } catch (std::out_of_range& e) {
94112       {
94113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94114       };
94115     } catch (std::exception& e) {
94116       {
94117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94118       };
94119     } catch (Dali::DaliException e) {
94120       {
94121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94122       };
94123     } catch (...) {
94124       {
94125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94126       };
94127     }
94128   }
94129
94130   jresult = (unsigned long)result;
94131   return jresult;
94132 }
94133
94134
94135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
94136   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94137   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
94138
94139   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94140   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94141   {
94142     try {
94143       (arg1)->reserve(arg2);
94144     } catch (std::out_of_range& e) {
94145       {
94146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94147       };
94148     } catch (std::exception& e) {
94149       {
94150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94151       };
94152     } catch (Dali::DaliException e) {
94153       {
94154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94155       };
94156     } catch (...) {
94157       {
94158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94159       };
94160     }
94161   }
94162
94163 }
94164
94165
94166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94167   void * jresult ;
94168   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94169
94170   {
94171     try {
94172       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94173     } catch (std::out_of_range& e) {
94174       {
94175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94176       };
94177     } catch (std::exception& e) {
94178       {
94179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94180       };
94181     } catch (Dali::DaliException e) {
94182       {
94183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94184       };
94185     } catch (...) {
94186       {
94187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94188       };
94189     }
94190   }
94191
94192   jresult = (void *)result;
94193   return jresult;
94194 }
94195
94196
94197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94198   void * jresult ;
94199   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94200   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94201
94202   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94203   if (!arg1) {
94204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94205     return 0;
94206   }
94207   {
94208     try {
94209       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);
94210     } catch (std::out_of_range& e) {
94211       {
94212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94213       };
94214     } catch (std::exception& e) {
94215       {
94216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94217       };
94218     } catch (Dali::DaliException e) {
94219       {
94220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94221       };
94222     } catch (...) {
94223       {
94224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94225       };
94226     }
94227   }
94228
94229   jresult = (void *)result;
94230   return jresult;
94231 }
94232
94233
94234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
94235   void * jresult ;
94236   int arg1 ;
94237   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94238
94239   arg1 = (int)jarg1;
94240   {
94241     try {
94242       try {
94243         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);
94244       }
94245       catch(std::out_of_range &_e) {
94246         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94247         return 0;
94248       }
94249
94250     } catch (std::out_of_range& e) {
94251       {
94252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94253       };
94254     } catch (std::exception& e) {
94255       {
94256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94257       };
94258     } catch (Dali::DaliException e) {
94259       {
94260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94261       };
94262     } catch (...) {
94263       {
94264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94265       };
94266     }
94267   }
94268
94269   jresult = (void *)result;
94270   return jresult;
94271 }
94272
94273
94274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94275   void * jresult ;
94276   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94277   int arg2 ;
94278   std::pair< unsigned int,Dali::Actor > result;
94279
94280   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94281   arg2 = (int)jarg2;
94282   {
94283     try {
94284       try {
94285         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94286       }
94287       catch(std::out_of_range &_e) {
94288         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94289         return 0;
94290       }
94291
94292     } catch (std::out_of_range& e) {
94293       {
94294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94295       };
94296     } catch (std::exception& e) {
94297       {
94298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94299       };
94300     } catch (Dali::DaliException e) {
94301       {
94302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94303       };
94304     } catch (...) {
94305       {
94306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94307       };
94308     }
94309   }
94310
94311   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94312   return jresult;
94313 }
94314
94315
94316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94317   void * jresult ;
94318   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94319   int arg2 ;
94320   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94321
94322   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94323   arg2 = (int)jarg2;
94324   {
94325     try {
94326       try {
94327         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94328       }
94329       catch(std::out_of_range &_e) {
94330         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94331         return 0;
94332       }
94333
94334     } catch (std::out_of_range& e) {
94335       {
94336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94337       };
94338     } catch (std::exception& e) {
94339       {
94340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94341       };
94342     } catch (Dali::DaliException e) {
94343       {
94344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94345       };
94346     } catch (...) {
94347       {
94348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94349       };
94350     }
94351   }
94352
94353   jresult = (void *)result;
94354   return jresult;
94355 }
94356
94357
94358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94359   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94360   int arg2 ;
94361   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94362
94363   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94364   arg2 = (int)jarg2;
94365   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94366   if (!arg3) {
94367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94368     return ;
94369   }
94370   {
94371     try {
94372       try {
94373         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);
94374       }
94375       catch(std::out_of_range &_e) {
94376         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94377         return ;
94378       }
94379
94380     } catch (std::out_of_range& e) {
94381       {
94382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94383       };
94384     } catch (std::exception& e) {
94385       {
94386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94387       };
94388     } catch (Dali::DaliException e) {
94389       {
94390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94391       };
94392     } catch (...) {
94393       {
94394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94395       };
94396     }
94397   }
94398
94399 }
94400
94401
94402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94403   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94404   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94405
94406   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94407   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94408   if (!arg2) {
94409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94410     return ;
94411   }
94412   {
94413     try {
94414       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);
94415     } catch (std::out_of_range& e) {
94416       {
94417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94418       };
94419     } catch (std::exception& e) {
94420       {
94421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94422       };
94423     } catch (Dali::DaliException e) {
94424       {
94425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94426       };
94427     } catch (...) {
94428       {
94429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94430       };
94431     }
94432   }
94433
94434 }
94435
94436
94437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94438   void * jresult ;
94439   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94440   int arg2 ;
94441   int arg3 ;
94442   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94443
94444   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94445   arg2 = (int)jarg2;
94446   arg3 = (int)jarg3;
94447   {
94448     try {
94449       try {
94450         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);
94451       }
94452       catch(std::out_of_range &_e) {
94453         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94454         return 0;
94455       }
94456       catch(std::invalid_argument &_e) {
94457         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94458         return 0;
94459       }
94460
94461     } catch (std::out_of_range& e) {
94462       {
94463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94464       };
94465     } catch (std::exception& e) {
94466       {
94467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94468       };
94469     } catch (Dali::DaliException e) {
94470       {
94471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94472       };
94473     } catch (...) {
94474       {
94475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94476       };
94477     }
94478   }
94479
94480   jresult = (void *)result;
94481   return jresult;
94482 }
94483
94484
94485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94486   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94487   int arg2 ;
94488   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94489
94490   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94491   arg2 = (int)jarg2;
94492   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94493   if (!arg3) {
94494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94495     return ;
94496   }
94497   {
94498     try {
94499       try {
94500         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);
94501       }
94502       catch(std::out_of_range &_e) {
94503         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94504         return ;
94505       }
94506
94507     } catch (std::out_of_range& e) {
94508       {
94509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94510       };
94511     } catch (std::exception& e) {
94512       {
94513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94514       };
94515     } catch (Dali::DaliException e) {
94516       {
94517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94518       };
94519     } catch (...) {
94520       {
94521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94522       };
94523     }
94524   }
94525
94526 }
94527
94528
94529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94530   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94531   int arg2 ;
94532   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94533
94534   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94535   arg2 = (int)jarg2;
94536   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94537   if (!arg3) {
94538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94539     return ;
94540   }
94541   {
94542     try {
94543       try {
94544         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);
94545       }
94546       catch(std::out_of_range &_e) {
94547         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94548         return ;
94549       }
94550
94551     } catch (std::out_of_range& e) {
94552       {
94553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94554       };
94555     } catch (std::exception& e) {
94556       {
94557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94558       };
94559     } catch (Dali::DaliException e) {
94560       {
94561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94562       };
94563     } catch (...) {
94564       {
94565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94566       };
94567     }
94568   }
94569
94570 }
94571
94572
94573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94574   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94575   int arg2 ;
94576
94577   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94578   arg2 = (int)jarg2;
94579   {
94580     try {
94581       try {
94582         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94583       }
94584       catch(std::out_of_range &_e) {
94585         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94586         return ;
94587       }
94588
94589     } catch (std::out_of_range& e) {
94590       {
94591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94592       };
94593     } catch (std::exception& e) {
94594       {
94595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94596       };
94597     } catch (Dali::DaliException e) {
94598       {
94599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94600       };
94601     } catch (...) {
94602       {
94603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94604       };
94605     }
94606   }
94607
94608 }
94609
94610
94611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94612   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94613   int arg2 ;
94614   int arg3 ;
94615
94616   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94617   arg2 = (int)jarg2;
94618   arg3 = (int)jarg3;
94619   {
94620     try {
94621       try {
94622         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94623       }
94624       catch(std::out_of_range &_e) {
94625         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94626         return ;
94627       }
94628       catch(std::invalid_argument &_e) {
94629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94630         return ;
94631       }
94632
94633     } catch (std::out_of_range& e) {
94634       {
94635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94636       };
94637     } catch (std::exception& e) {
94638       {
94639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94640       };
94641     } catch (Dali::DaliException e) {
94642       {
94643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94644       };
94645     } catch (...) {
94646       {
94647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94648       };
94649     }
94650   }
94651
94652 }
94653
94654
94655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94656   void * jresult ;
94657   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94658   int arg2 ;
94659   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94660
94661   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94662   if (!arg1) {
94663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94664     return 0;
94665   }
94666   arg2 = (int)jarg2;
94667   {
94668     try {
94669       try {
94670         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);
94671       }
94672       catch(std::out_of_range &_e) {
94673         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94674         return 0;
94675       }
94676
94677     } catch (std::out_of_range& e) {
94678       {
94679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94680       };
94681     } catch (std::exception& e) {
94682       {
94683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94684       };
94685     } catch (Dali::DaliException e) {
94686       {
94687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94688       };
94689     } catch (...) {
94690       {
94691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94692       };
94693     }
94694   }
94695
94696   jresult = (void *)result;
94697   return jresult;
94698 }
94699
94700
94701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94702   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94703
94704   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94705   {
94706     try {
94707       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94708     } catch (std::out_of_range& e) {
94709       {
94710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94711       };
94712     } catch (std::exception& e) {
94713       {
94714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94715       };
94716     } catch (Dali::DaliException e) {
94717       {
94718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94719       };
94720     } catch (...) {
94721       {
94722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94723       };
94724     }
94725   }
94726
94727 }
94728
94729
94730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94731   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94732   int arg2 ;
94733   int arg3 ;
94734
94735   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94736   arg2 = (int)jarg2;
94737   arg3 = (int)jarg3;
94738   {
94739     try {
94740       try {
94741         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94742       }
94743       catch(std::out_of_range &_e) {
94744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94745         return ;
94746       }
94747       catch(std::invalid_argument &_e) {
94748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94749         return ;
94750       }
94751
94752     } catch (std::out_of_range& e) {
94753       {
94754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94755       };
94756     } catch (std::exception& e) {
94757       {
94758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94759       };
94760     } catch (Dali::DaliException e) {
94761       {
94762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94763       };
94764     } catch (...) {
94765       {
94766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94767       };
94768     }
94769   }
94770
94771 }
94772
94773
94774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94775   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94776   int arg2 ;
94777   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94778
94779   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94780   arg2 = (int)jarg2;
94781   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94782   if (!arg3) {
94783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94784     return ;
94785   }
94786   {
94787     try {
94788       try {
94789         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);
94790       }
94791       catch(std::out_of_range &_e) {
94792         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94793         return ;
94794       }
94795
94796     } catch (std::out_of_range& e) {
94797       {
94798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94799       };
94800     } catch (std::exception& e) {
94801       {
94802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94803       };
94804     } catch (Dali::DaliException e) {
94805       {
94806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94807       };
94808     } catch (...) {
94809       {
94810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94811       };
94812     }
94813   }
94814
94815 }
94816
94817
94818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94819   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94820
94821   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94822   {
94823     try {
94824       delete arg1;
94825     } catch (std::out_of_range& e) {
94826       {
94827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94828       };
94829     } catch (std::exception& e) {
94830       {
94831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94832       };
94833     } catch (Dali::DaliException e) {
94834       {
94835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94836       };
94837     } catch (...) {
94838       {
94839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94840       };
94841     }
94842   }
94843
94844 }
94845
94846
94847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94848   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94849
94850   arg1 = (std::vector< Dali::Actor > *)jarg1;
94851   {
94852     try {
94853       (arg1)->clear();
94854     } catch (std::out_of_range& e) {
94855       {
94856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94857       };
94858     } catch (std::exception& e) {
94859       {
94860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94861       };
94862     } catch (Dali::DaliException e) {
94863       {
94864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94865       };
94866     } catch (...) {
94867       {
94868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94869       };
94870     }
94871   }
94872
94873 }
94874
94875
94876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94877   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94878   Dali::Actor *arg2 = 0 ;
94879
94880   arg1 = (std::vector< Dali::Actor > *)jarg1;
94881   arg2 = (Dali::Actor *)jarg2;
94882   if (!arg2) {
94883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94884     return ;
94885   }
94886   {
94887     try {
94888       (arg1)->push_back((Dali::Actor const &)*arg2);
94889     } catch (std::out_of_range& e) {
94890       {
94891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94892       };
94893     } catch (std::exception& e) {
94894       {
94895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94896       };
94897     } catch (Dali::DaliException e) {
94898       {
94899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94900       };
94901     } catch (...) {
94902       {
94903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94904       };
94905     }
94906   }
94907
94908 }
94909
94910
94911 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94912   unsigned long jresult ;
94913   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94914   std::vector< Dali::Actor >::size_type result;
94915
94916   arg1 = (std::vector< Dali::Actor > *)jarg1;
94917   {
94918     try {
94919       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94920     } catch (std::out_of_range& e) {
94921       {
94922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94923       };
94924     } catch (std::exception& e) {
94925       {
94926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94927       };
94928     } catch (Dali::DaliException e) {
94929       {
94930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94931       };
94932     } catch (...) {
94933       {
94934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94935       };
94936     }
94937   }
94938
94939   jresult = (unsigned long)result;
94940   return jresult;
94941 }
94942
94943
94944 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94945   unsigned long jresult ;
94946   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94947   std::vector< Dali::Actor >::size_type result;
94948
94949   arg1 = (std::vector< Dali::Actor > *)jarg1;
94950   {
94951     try {
94952       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94953     } catch (std::out_of_range& e) {
94954       {
94955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94956       };
94957     } catch (std::exception& e) {
94958       {
94959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94960       };
94961     } catch (Dali::DaliException e) {
94962       {
94963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94964       };
94965     } catch (...) {
94966       {
94967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94968       };
94969     }
94970   }
94971
94972   jresult = (unsigned long)result;
94973   return jresult;
94974 }
94975
94976
94977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94978   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94979   std::vector< Dali::Actor >::size_type arg2 ;
94980
94981   arg1 = (std::vector< Dali::Actor > *)jarg1;
94982   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94983   {
94984     try {
94985       (arg1)->reserve(arg2);
94986     } catch (std::out_of_range& e) {
94987       {
94988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94989       };
94990     } catch (std::exception& e) {
94991       {
94992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94993       };
94994     } catch (Dali::DaliException e) {
94995       {
94996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94997       };
94998     } catch (...) {
94999       {
95000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95001       };
95002     }
95003   }
95004
95005 }
95006
95007
95008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
95009   void * jresult ;
95010   std::vector< Dali::Actor > *result = 0 ;
95011
95012   {
95013     try {
95014       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
95015     } catch (std::out_of_range& e) {
95016       {
95017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95018       };
95019     } catch (std::exception& e) {
95020       {
95021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95022       };
95023     } catch (Dali::DaliException e) {
95024       {
95025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95026       };
95027     } catch (...) {
95028       {
95029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95030       };
95031     }
95032   }
95033
95034   jresult = (void *)result;
95035   return jresult;
95036 }
95037
95038
95039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
95040   void * jresult ;
95041   std::vector< Dali::Actor > *arg1 = 0 ;
95042   std::vector< Dali::Actor > *result = 0 ;
95043
95044   arg1 = (std::vector< Dali::Actor > *)jarg1;
95045   if (!arg1) {
95046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95047     return 0;
95048   }
95049   {
95050     try {
95051       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
95052     } catch (std::out_of_range& e) {
95053       {
95054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95055       };
95056     } catch (std::exception& e) {
95057       {
95058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95059       };
95060     } catch (Dali::DaliException e) {
95061       {
95062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95063       };
95064     } catch (...) {
95065       {
95066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95067       };
95068     }
95069   }
95070
95071   jresult = (void *)result;
95072   return jresult;
95073 }
95074
95075
95076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
95077   void * jresult ;
95078   int arg1 ;
95079   std::vector< Dali::Actor > *result = 0 ;
95080
95081   arg1 = (int)jarg1;
95082   {
95083     try {
95084       try {
95085         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95086       }
95087       catch(std::out_of_range &_e) {
95088         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95089         return 0;
95090       }
95091
95092     } catch (std::out_of_range& e) {
95093       {
95094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95095       };
95096     } catch (std::exception& e) {
95097       {
95098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95099       };
95100     } catch (Dali::DaliException e) {
95101       {
95102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95103       };
95104     } catch (...) {
95105       {
95106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95107       };
95108     }
95109   }
95110
95111   jresult = (void *)result;
95112   return jresult;
95113 }
95114
95115
95116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95117   void * jresult ;
95118   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95119   int arg2 ;
95120   Dali::Actor result;
95121
95122   arg1 = (std::vector< Dali::Actor > *)jarg1;
95123   arg2 = (int)jarg2;
95124   {
95125     try {
95126       try {
95127         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95128       }
95129       catch(std::out_of_range &_e) {
95130         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95131         return 0;
95132       }
95133
95134     } catch (std::out_of_range& e) {
95135       {
95136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95137       };
95138     } catch (std::exception& e) {
95139       {
95140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95141       };
95142     } catch (Dali::DaliException e) {
95143       {
95144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95145       };
95146     } catch (...) {
95147       {
95148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95149       };
95150     }
95151   }
95152
95153   jresult = new Dali::Actor((const Dali::Actor &)result);
95154   return jresult;
95155 }
95156
95157
95158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95159   void * jresult ;
95160   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95161   int arg2 ;
95162   Dali::Actor *result = 0 ;
95163
95164   arg1 = (std::vector< Dali::Actor > *)jarg1;
95165   arg2 = (int)jarg2;
95166   {
95167     try {
95168       try {
95169         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95170       }
95171       catch(std::out_of_range &_e) {
95172         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95173         return 0;
95174       }
95175
95176     } catch (std::out_of_range& e) {
95177       {
95178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95179       };
95180     } catch (std::exception& e) {
95181       {
95182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95183       };
95184     } catch (Dali::DaliException e) {
95185       {
95186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95187       };
95188     } catch (...) {
95189       {
95190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95191       };
95192     }
95193   }
95194
95195   jresult = (void *)result;
95196   return jresult;
95197 }
95198
95199
95200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95201   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95202   int arg2 ;
95203   Dali::Actor *arg3 = 0 ;
95204
95205   arg1 = (std::vector< Dali::Actor > *)jarg1;
95206   arg2 = (int)jarg2;
95207   arg3 = (Dali::Actor *)jarg3;
95208   if (!arg3) {
95209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95210     return ;
95211   }
95212   {
95213     try {
95214       try {
95215         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95216       }
95217       catch(std::out_of_range &_e) {
95218         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95219         return ;
95220       }
95221
95222     } catch (std::out_of_range& e) {
95223       {
95224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95225       };
95226     } catch (std::exception& e) {
95227       {
95228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95229       };
95230     } catch (Dali::DaliException e) {
95231       {
95232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95233       };
95234     } catch (...) {
95235       {
95236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95237       };
95238     }
95239   }
95240
95241 }
95242
95243
95244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95245   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95246   std::vector< Dali::Actor > *arg2 = 0 ;
95247
95248   arg1 = (std::vector< Dali::Actor > *)jarg1;
95249   arg2 = (std::vector< Dali::Actor > *)jarg2;
95250   if (!arg2) {
95251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95252     return ;
95253   }
95254   {
95255     try {
95256       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95257     } catch (std::out_of_range& e) {
95258       {
95259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95260       };
95261     } catch (std::exception& e) {
95262       {
95263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95264       };
95265     } catch (Dali::DaliException e) {
95266       {
95267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95268       };
95269     } catch (...) {
95270       {
95271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95272       };
95273     }
95274   }
95275
95276 }
95277
95278
95279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95280   void * jresult ;
95281   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95282   int arg2 ;
95283   int arg3 ;
95284   std::vector< Dali::Actor > *result = 0 ;
95285
95286   arg1 = (std::vector< Dali::Actor > *)jarg1;
95287   arg2 = (int)jarg2;
95288   arg3 = (int)jarg3;
95289   {
95290     try {
95291       try {
95292         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95293       }
95294       catch(std::out_of_range &_e) {
95295         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95296         return 0;
95297       }
95298       catch(std::invalid_argument &_e) {
95299         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95300         return 0;
95301       }
95302
95303     } catch (std::out_of_range& e) {
95304       {
95305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95306       };
95307     } catch (std::exception& e) {
95308       {
95309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95310       };
95311     } catch (Dali::DaliException e) {
95312       {
95313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95314       };
95315     } catch (...) {
95316       {
95317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95318       };
95319     }
95320   }
95321
95322   jresult = (void *)result;
95323   return jresult;
95324 }
95325
95326
95327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95328   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95329   int arg2 ;
95330   Dali::Actor *arg3 = 0 ;
95331
95332   arg1 = (std::vector< Dali::Actor > *)jarg1;
95333   arg2 = (int)jarg2;
95334   arg3 = (Dali::Actor *)jarg3;
95335   if (!arg3) {
95336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95337     return ;
95338   }
95339   {
95340     try {
95341       try {
95342         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95343       }
95344       catch(std::out_of_range &_e) {
95345         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95346         return ;
95347       }
95348
95349     } catch (std::out_of_range& e) {
95350       {
95351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95352       };
95353     } catch (std::exception& e) {
95354       {
95355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95356       };
95357     } catch (Dali::DaliException e) {
95358       {
95359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95360       };
95361     } catch (...) {
95362       {
95363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95364       };
95365     }
95366   }
95367
95368 }
95369
95370
95371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95372   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95373   int arg2 ;
95374   std::vector< Dali::Actor > *arg3 = 0 ;
95375
95376   arg1 = (std::vector< Dali::Actor > *)jarg1;
95377   arg2 = (int)jarg2;
95378   arg3 = (std::vector< Dali::Actor > *)jarg3;
95379   if (!arg3) {
95380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95381     return ;
95382   }
95383   {
95384     try {
95385       try {
95386         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95387       }
95388       catch(std::out_of_range &_e) {
95389         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95390         return ;
95391       }
95392
95393     } catch (std::out_of_range& e) {
95394       {
95395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95396       };
95397     } catch (std::exception& e) {
95398       {
95399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95400       };
95401     } catch (Dali::DaliException e) {
95402       {
95403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95404       };
95405     } catch (...) {
95406       {
95407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95408       };
95409     }
95410   }
95411
95412 }
95413
95414
95415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95416   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95417   int arg2 ;
95418
95419   arg1 = (std::vector< Dali::Actor > *)jarg1;
95420   arg2 = (int)jarg2;
95421   {
95422     try {
95423       try {
95424         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95425       }
95426       catch(std::out_of_range &_e) {
95427         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95428         return ;
95429       }
95430
95431     } catch (std::out_of_range& e) {
95432       {
95433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95434       };
95435     } catch (std::exception& e) {
95436       {
95437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95438       };
95439     } catch (Dali::DaliException e) {
95440       {
95441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95442       };
95443     } catch (...) {
95444       {
95445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95446       };
95447     }
95448   }
95449
95450 }
95451
95452
95453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95454   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95455   int arg2 ;
95456   int arg3 ;
95457
95458   arg1 = (std::vector< Dali::Actor > *)jarg1;
95459   arg2 = (int)jarg2;
95460   arg3 = (int)jarg3;
95461   {
95462     try {
95463       try {
95464         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95465       }
95466       catch(std::out_of_range &_e) {
95467         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95468         return ;
95469       }
95470       catch(std::invalid_argument &_e) {
95471         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95472         return ;
95473       }
95474
95475     } catch (std::out_of_range& e) {
95476       {
95477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95478       };
95479     } catch (std::exception& e) {
95480       {
95481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95482       };
95483     } catch (Dali::DaliException e) {
95484       {
95485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95486       };
95487     } catch (...) {
95488       {
95489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95490       };
95491     }
95492   }
95493
95494 }
95495
95496
95497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95498   void * jresult ;
95499   Dali::Actor *arg1 = 0 ;
95500   int arg2 ;
95501   std::vector< Dali::Actor > *result = 0 ;
95502
95503   arg1 = (Dali::Actor *)jarg1;
95504   if (!arg1) {
95505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95506     return 0;
95507   }
95508   arg2 = (int)jarg2;
95509   {
95510     try {
95511       try {
95512         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95513       }
95514       catch(std::out_of_range &_e) {
95515         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95516         return 0;
95517       }
95518
95519     } catch (std::out_of_range& e) {
95520       {
95521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95522       };
95523     } catch (std::exception& e) {
95524       {
95525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95526       };
95527     } catch (Dali::DaliException e) {
95528       {
95529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95530       };
95531     } catch (...) {
95532       {
95533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95534       };
95535     }
95536   }
95537
95538   jresult = (void *)result;
95539   return jresult;
95540 }
95541
95542
95543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95544   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95545
95546   arg1 = (std::vector< Dali::Actor > *)jarg1;
95547   {
95548     try {
95549       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95550     } catch (std::out_of_range& e) {
95551       {
95552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95553       };
95554     } catch (std::exception& e) {
95555       {
95556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95557       };
95558     } catch (Dali::DaliException e) {
95559       {
95560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95561       };
95562     } catch (...) {
95563       {
95564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95565       };
95566     }
95567   }
95568
95569 }
95570
95571
95572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95573   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95574   int arg2 ;
95575   int arg3 ;
95576
95577   arg1 = (std::vector< Dali::Actor > *)jarg1;
95578   arg2 = (int)jarg2;
95579   arg3 = (int)jarg3;
95580   {
95581     try {
95582       try {
95583         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95584       }
95585       catch(std::out_of_range &_e) {
95586         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95587         return ;
95588       }
95589       catch(std::invalid_argument &_e) {
95590         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95591         return ;
95592       }
95593
95594     } catch (std::out_of_range& e) {
95595       {
95596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95597       };
95598     } catch (std::exception& e) {
95599       {
95600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95601       };
95602     } catch (Dali::DaliException e) {
95603       {
95604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95605       };
95606     } catch (...) {
95607       {
95608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95609       };
95610     }
95611   }
95612
95613 }
95614
95615
95616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95617   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95618   int arg2 ;
95619   std::vector< Dali::Actor > *arg3 = 0 ;
95620
95621   arg1 = (std::vector< Dali::Actor > *)jarg1;
95622   arg2 = (int)jarg2;
95623   arg3 = (std::vector< Dali::Actor > *)jarg3;
95624   if (!arg3) {
95625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95626     return ;
95627   }
95628   {
95629     try {
95630       try {
95631         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95632       }
95633       catch(std::out_of_range &_e) {
95634         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95635         return ;
95636       }
95637
95638     } catch (std::out_of_range& e) {
95639       {
95640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95641       };
95642     } catch (std::exception& e) {
95643       {
95644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95645       };
95646     } catch (Dali::DaliException e) {
95647       {
95648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95649       };
95650     } catch (...) {
95651       {
95652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95653       };
95654     }
95655   }
95656
95657 }
95658
95659
95660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95661   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95662
95663   arg1 = (std::vector< Dali::Actor > *)jarg1;
95664   {
95665     try {
95666       delete arg1;
95667     } catch (std::out_of_range& e) {
95668       {
95669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95670       };
95671     } catch (std::exception& e) {
95672       {
95673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95674       };
95675     } catch (Dali::DaliException e) {
95676       {
95677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95678       };
95679     } catch (...) {
95680       {
95681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95682       };
95683     }
95684   }
95685
95686 }
95687
95688
95689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95690   unsigned int jresult ;
95691   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95692   bool result;
95693
95694   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95695   {
95696     try {
95697       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95698     } catch (std::out_of_range& e) {
95699       {
95700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95701       };
95702     } catch (std::exception& e) {
95703       {
95704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95705       };
95706     } catch (Dali::DaliException e) {
95707       {
95708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95709       };
95710     } catch (...) {
95711       {
95712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95713       };
95714     }
95715   }
95716
95717   jresult = result;
95718   return jresult;
95719 }
95720
95721
95722 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95723   unsigned long jresult ;
95724   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95725   std::size_t result;
95726
95727   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95728   {
95729     try {
95730       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95731     } catch (std::out_of_range& e) {
95732       {
95733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95734       };
95735     } catch (std::exception& e) {
95736       {
95737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95738       };
95739     } catch (Dali::DaliException e) {
95740       {
95741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95742       };
95743     } catch (...) {
95744       {
95745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95746       };
95747     }
95748   }
95749
95750   jresult = (unsigned long)result;
95751   return jresult;
95752 }
95753
95754
95755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95756   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95757   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95758
95759   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95760   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95761   {
95762     try {
95763       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95764     } catch (std::out_of_range& e) {
95765       {
95766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95767       };
95768     } catch (std::exception& e) {
95769       {
95770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95771       };
95772     } catch (Dali::DaliException e) {
95773       {
95774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95775       };
95776     } catch (...) {
95777       {
95778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95779       };
95780     }
95781   }
95782
95783 }
95784
95785
95786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95787   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95788   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95789
95790   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95791   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95792   {
95793     try {
95794       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95795     } catch (std::out_of_range& e) {
95796       {
95797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95798       };
95799     } catch (std::exception& e) {
95800       {
95801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95802       };
95803     } catch (Dali::DaliException e) {
95804       {
95805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95806       };
95807     } catch (...) {
95808       {
95809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95810       };
95811     }
95812   }
95813
95814 }
95815
95816
95817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95818   unsigned int jresult ;
95819   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95820   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95821   bool result;
95822
95823   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95824   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95825   if (!arg2) {
95826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95827     return 0;
95828   }
95829   {
95830     try {
95831       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95832     } catch (std::out_of_range& e) {
95833       {
95834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95835       };
95836     } catch (std::exception& e) {
95837       {
95838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95839       };
95840     } catch (Dali::DaliException e) {
95841       {
95842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95843       };
95844     } catch (...) {
95845       {
95846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95847       };
95848     }
95849   }
95850
95851   jresult = result;
95852   return jresult;
95853 }
95854
95855
95856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95857   void * jresult ;
95858   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95859
95860   {
95861     try {
95862       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95863     } catch (std::out_of_range& e) {
95864       {
95865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95866       };
95867     } catch (std::exception& e) {
95868       {
95869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95870       };
95871     } catch (Dali::DaliException e) {
95872       {
95873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95874       };
95875     } catch (...) {
95876       {
95877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95878       };
95879     }
95880   }
95881
95882   jresult = (void *)result;
95883   return jresult;
95884 }
95885
95886
95887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95888   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95889
95890   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95891   {
95892     try {
95893       delete arg1;
95894     } catch (std::out_of_range& e) {
95895       {
95896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95897       };
95898     } catch (std::exception& e) {
95899       {
95900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95901       };
95902     } catch (Dali::DaliException e) {
95903       {
95904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95905       };
95906     } catch (...) {
95907       {
95908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95909       };
95910     }
95911   }
95912
95913 }
95914
95915
95916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95917   unsigned int jresult ;
95918   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95919   bool result;
95920
95921   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95922   {
95923     try {
95924       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);
95925     } catch (std::out_of_range& e) {
95926       {
95927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95928       };
95929     } catch (std::exception& e) {
95930       {
95931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95932       };
95933     } catch (Dali::DaliException e) {
95934       {
95935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95936       };
95937     } catch (...) {
95938       {
95939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95940       };
95941     }
95942   }
95943
95944   jresult = result;
95945   return jresult;
95946 }
95947
95948
95949 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95950   unsigned long jresult ;
95951   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95952   std::size_t result;
95953
95954   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95955   {
95956     try {
95957       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);
95958     } catch (std::out_of_range& e) {
95959       {
95960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95961       };
95962     } catch (std::exception& e) {
95963       {
95964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95965       };
95966     } catch (Dali::DaliException e) {
95967       {
95968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95969       };
95970     } catch (...) {
95971       {
95972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95973       };
95974     }
95975   }
95976
95977   jresult = (unsigned long)result;
95978   return jresult;
95979 }
95980
95981
95982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95983   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95984   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95985
95986   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95987   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95988   {
95989     try {
95990       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95991     } catch (std::out_of_range& e) {
95992       {
95993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95994       };
95995     } catch (std::exception& e) {
95996       {
95997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95998       };
95999     } catch (Dali::DaliException e) {
96000       {
96001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96002       };
96003     } catch (...) {
96004       {
96005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96006       };
96007     }
96008   }
96009
96010 }
96011
96012
96013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
96014   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96015   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96016
96017   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96018   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96019   {
96020     try {
96021       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
96022     } catch (std::out_of_range& e) {
96023       {
96024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96025       };
96026     } catch (std::exception& e) {
96027       {
96028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96029       };
96030     } catch (Dali::DaliException e) {
96031       {
96032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96033       };
96034     } catch (...) {
96035       {
96036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96037       };
96038     }
96039   }
96040
96041 }
96042
96043
96044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96045   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96046   Dali::Actor arg2 ;
96047   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
96048   Dali::Actor *argp2 ;
96049
96050   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96051   argp2 = (Dali::Actor *)jarg2;
96052   if (!argp2) {
96053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96054     return ;
96055   }
96056   arg2 = *argp2;
96057   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
96058   {
96059     try {
96060       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
96061     } catch (std::out_of_range& e) {
96062       {
96063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96064       };
96065     } catch (std::exception& e) {
96066       {
96067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96068       };
96069     } catch (Dali::DaliException e) {
96070       {
96071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96072       };
96073     } catch (...) {
96074       {
96075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96076       };
96077     }
96078   }
96079
96080 }
96081
96082
96083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96084   void * jresult ;
96085   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96086
96087   {
96088     try {
96089       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96090     } catch (std::out_of_range& e) {
96091       {
96092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96093       };
96094     } catch (std::exception& e) {
96095       {
96096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96097       };
96098     } catch (Dali::DaliException e) {
96099       {
96100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96101       };
96102     } catch (...) {
96103       {
96104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96105       };
96106     }
96107   }
96108
96109   jresult = (void *)result;
96110   return jresult;
96111 }
96112
96113
96114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96115   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96116
96117   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96118   {
96119     try {
96120       delete arg1;
96121     } catch (std::out_of_range& e) {
96122       {
96123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96124       };
96125     } catch (std::exception& e) {
96126       {
96127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96128       };
96129     } catch (Dali::DaliException e) {
96130       {
96131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96132       };
96133     } catch (...) {
96134       {
96135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96136       };
96137     }
96138   }
96139
96140 }
96141
96142
96143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96144   unsigned int jresult ;
96145   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96146   bool result;
96147
96148   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96149   {
96150     try {
96151       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96152     } catch (std::out_of_range& e) {
96153       {
96154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96155       };
96156     } catch (std::exception& e) {
96157       {
96158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96159       };
96160     } catch (Dali::DaliException e) {
96161       {
96162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96163       };
96164     } catch (...) {
96165       {
96166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96167       };
96168     }
96169   }
96170
96171   jresult = result;
96172   return jresult;
96173 }
96174
96175
96176 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96177   unsigned long jresult ;
96178   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96179   std::size_t result;
96180
96181   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96182   {
96183     try {
96184       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96185     } catch (std::out_of_range& e) {
96186       {
96187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96188       };
96189     } catch (std::exception& e) {
96190       {
96191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96192       };
96193     } catch (Dali::DaliException e) {
96194       {
96195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96196       };
96197     } catch (...) {
96198       {
96199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96200       };
96201     }
96202   }
96203
96204   jresult = (unsigned long)result;
96205   return jresult;
96206 }
96207
96208
96209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96210   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96211   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96212
96213   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96214   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96215   {
96216     try {
96217       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96218     } catch (std::out_of_range& e) {
96219       {
96220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96221       };
96222     } catch (std::exception& e) {
96223       {
96224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96225       };
96226     } catch (Dali::DaliException e) {
96227       {
96228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96229       };
96230     } catch (...) {
96231       {
96232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96233       };
96234     }
96235   }
96236
96237 }
96238
96239
96240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96241   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96242   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96243
96244   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96245   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96246   {
96247     try {
96248       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96249     } catch (std::out_of_range& e) {
96250       {
96251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96252       };
96253     } catch (std::exception& e) {
96254       {
96255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96256       };
96257     } catch (Dali::DaliException e) {
96258       {
96259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96260       };
96261     } catch (...) {
96262       {
96263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96264       };
96265     }
96266   }
96267
96268 }
96269
96270
96271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96272   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96273   Dali::Actor arg2 ;
96274   Dali::Actor arg3 ;
96275   Dali::Actor *argp2 ;
96276   Dali::Actor *argp3 ;
96277
96278   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96279   argp2 = (Dali::Actor *)jarg2;
96280   if (!argp2) {
96281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96282     return ;
96283   }
96284   arg2 = *argp2;
96285   argp3 = (Dali::Actor *)jarg3;
96286   if (!argp3) {
96287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96288     return ;
96289   }
96290   arg3 = *argp3;
96291   {
96292     try {
96293       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96294     } catch (std::out_of_range& e) {
96295       {
96296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96297       };
96298     } catch (std::exception& e) {
96299       {
96300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96301       };
96302     } catch (Dali::DaliException e) {
96303       {
96304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96305       };
96306     } catch (...) {
96307       {
96308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96309       };
96310     }
96311   }
96312
96313 }
96314
96315
96316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96317   void * jresult ;
96318   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96319
96320   {
96321     try {
96322       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96323     } catch (std::out_of_range& e) {
96324       {
96325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96326       };
96327     } catch (std::exception& e) {
96328       {
96329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96330       };
96331     } catch (Dali::DaliException e) {
96332       {
96333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96334       };
96335     } catch (...) {
96336       {
96337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96338       };
96339     }
96340   }
96341
96342   jresult = (void *)result;
96343   return jresult;
96344 }
96345
96346
96347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96348   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96349
96350   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96351   {
96352     try {
96353       delete arg1;
96354     } catch (std::out_of_range& e) {
96355       {
96356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96357       };
96358     } catch (std::exception& e) {
96359       {
96360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96361       };
96362     } catch (Dali::DaliException e) {
96363       {
96364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96365       };
96366     } catch (...) {
96367       {
96368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96369       };
96370     }
96371   }
96372
96373 }
96374
96375
96376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96377   unsigned int jresult ;
96378   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96379   bool result;
96380
96381   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96382   {
96383     try {
96384       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96385     } catch (std::out_of_range& e) {
96386       {
96387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96388       };
96389     } catch (std::exception& e) {
96390       {
96391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96392       };
96393     } catch (Dali::DaliException e) {
96394       {
96395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96396       };
96397     } catch (...) {
96398       {
96399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96400       };
96401     }
96402   }
96403
96404   jresult = result;
96405   return jresult;
96406 }
96407
96408
96409 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96410   unsigned long jresult ;
96411   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96412   std::size_t result;
96413
96414   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96415   {
96416     try {
96417       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96418     } catch (std::out_of_range& e) {
96419       {
96420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96421       };
96422     } catch (std::exception& e) {
96423       {
96424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96425       };
96426     } catch (Dali::DaliException e) {
96427       {
96428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96429       };
96430     } catch (...) {
96431       {
96432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96433       };
96434     }
96435   }
96436
96437   jresult = (unsigned long)result;
96438   return jresult;
96439 }
96440
96441
96442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96443   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96444   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96445
96446   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96447   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96448   {
96449     try {
96450       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96451     } catch (std::out_of_range& e) {
96452       {
96453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96454       };
96455     } catch (std::exception& e) {
96456       {
96457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96458       };
96459     } catch (Dali::DaliException e) {
96460       {
96461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96462       };
96463     } catch (...) {
96464       {
96465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96466       };
96467     }
96468   }
96469
96470 }
96471
96472
96473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96474   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96475   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96476
96477   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96478   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96479   {
96480     try {
96481       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96482     } catch (std::out_of_range& e) {
96483       {
96484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96485       };
96486     } catch (std::exception& e) {
96487       {
96488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96489       };
96490     } catch (Dali::DaliException e) {
96491       {
96492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96493       };
96494     } catch (...) {
96495       {
96496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96497       };
96498     }
96499   }
96500
96501 }
96502
96503
96504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96505   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96506   Dali::Actor arg2 ;
96507   bool arg3 ;
96508   Dali::Actor *argp2 ;
96509
96510   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96511   argp2 = (Dali::Actor *)jarg2;
96512   if (!argp2) {
96513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96514     return ;
96515   }
96516   arg2 = *argp2;
96517   arg3 = jarg3 ? true : false;
96518   {
96519     try {
96520       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96521     } catch (std::out_of_range& e) {
96522       {
96523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96524       };
96525     } catch (std::exception& e) {
96526       {
96527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96528       };
96529     } catch (Dali::DaliException e) {
96530       {
96531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96532       };
96533     } catch (...) {
96534       {
96535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96536       };
96537     }
96538   }
96539
96540 }
96541
96542
96543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96544   void * jresult ;
96545   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96546
96547   {
96548     try {
96549       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96550     } catch (std::out_of_range& e) {
96551       {
96552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96553       };
96554     } catch (std::exception& e) {
96555       {
96556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96557       };
96558     } catch (Dali::DaliException e) {
96559       {
96560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96561       };
96562     } catch (...) {
96563       {
96564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96565       };
96566     }
96567   }
96568
96569   jresult = (void *)result;
96570   return jresult;
96571 }
96572
96573
96574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96575   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96576
96577   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96578   {
96579     try {
96580       delete arg1;
96581     } catch (std::out_of_range& e) {
96582       {
96583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96584       };
96585     } catch (std::exception& e) {
96586       {
96587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96588       };
96589     } catch (Dali::DaliException e) {
96590       {
96591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96592       };
96593     } catch (...) {
96594       {
96595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96596       };
96597     }
96598   }
96599
96600 }
96601
96602
96603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96604   unsigned int jresult ;
96605   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96606   bool result;
96607
96608   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96609   {
96610     try {
96611       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);
96612     } catch (std::out_of_range& e) {
96613       {
96614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96615       };
96616     } catch (std::exception& e) {
96617       {
96618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96619       };
96620     } catch (Dali::DaliException e) {
96621       {
96622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96623       };
96624     } catch (...) {
96625       {
96626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96627       };
96628     }
96629   }
96630
96631   jresult = result;
96632   return jresult;
96633 }
96634
96635
96636 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96637   unsigned long jresult ;
96638   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96639   std::size_t result;
96640
96641   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96642   {
96643     try {
96644       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);
96645     } catch (std::out_of_range& e) {
96646       {
96647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96648       };
96649     } catch (std::exception& e) {
96650       {
96651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96652       };
96653     } catch (Dali::DaliException e) {
96654       {
96655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96656       };
96657     } catch (...) {
96658       {
96659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96660       };
96661     }
96662   }
96663
96664   jresult = (unsigned long)result;
96665   return jresult;
96666 }
96667
96668
96669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96670   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96671   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96672
96673   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96674   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96675   {
96676     try {
96677       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96678     } catch (std::out_of_range& e) {
96679       {
96680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96681       };
96682     } catch (std::exception& e) {
96683       {
96684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96685       };
96686     } catch (Dali::DaliException e) {
96687       {
96688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96689       };
96690     } catch (...) {
96691       {
96692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96693       };
96694     }
96695   }
96696
96697 }
96698
96699
96700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96701   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96702   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96703
96704   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96705   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96706   {
96707     try {
96708       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96709     } catch (std::out_of_range& e) {
96710       {
96711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96712       };
96713     } catch (std::exception& e) {
96714       {
96715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96716       };
96717     } catch (Dali::DaliException e) {
96718       {
96719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96720       };
96721     } catch (...) {
96722       {
96723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96724       };
96725     }
96726   }
96727
96728 }
96729
96730
96731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96732   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96733   Dali::Toolkit::StyleManager arg2 ;
96734   Dali::StyleChange::Type arg3 ;
96735   Dali::Toolkit::StyleManager *argp2 ;
96736
96737   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96738   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96739   if (!argp2) {
96740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96741     return ;
96742   }
96743   arg2 = *argp2;
96744   arg3 = (Dali::StyleChange::Type)jarg3;
96745   {
96746     try {
96747       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96748     } catch (std::out_of_range& e) {
96749       {
96750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96751       };
96752     } catch (std::exception& e) {
96753       {
96754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96755       };
96756     } catch (Dali::DaliException e) {
96757       {
96758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96759       };
96760     } catch (...) {
96761       {
96762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96763       };
96764     }
96765   }
96766
96767 }
96768
96769
96770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96771   void * jresult ;
96772   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96773
96774   {
96775     try {
96776       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96777     } catch (std::out_of_range& e) {
96778       {
96779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96780       };
96781     } catch (std::exception& e) {
96782       {
96783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96784       };
96785     } catch (Dali::DaliException e) {
96786       {
96787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96788       };
96789     } catch (...) {
96790       {
96791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96792       };
96793     }
96794   }
96795
96796   jresult = (void *)result;
96797   return jresult;
96798 }
96799
96800
96801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96802   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96803
96804   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96805   {
96806     try {
96807       delete arg1;
96808     } catch (std::out_of_range& e) {
96809       {
96810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96811       };
96812     } catch (std::exception& e) {
96813       {
96814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96815       };
96816     } catch (Dali::DaliException e) {
96817       {
96818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96819       };
96820     } catch (...) {
96821       {
96822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96823       };
96824     }
96825   }
96826
96827 }
96828
96829
96830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96831   unsigned int jresult ;
96832   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96833   bool result;
96834
96835   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96836   {
96837     try {
96838       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96839     } catch (std::out_of_range& e) {
96840       {
96841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96842       };
96843     } catch (std::exception& e) {
96844       {
96845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96846       };
96847     } catch (Dali::DaliException e) {
96848       {
96849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96850       };
96851     } catch (...) {
96852       {
96853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96854       };
96855     }
96856   }
96857
96858   jresult = result;
96859   return jresult;
96860 }
96861
96862
96863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96864   unsigned long jresult ;
96865   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96866   std::size_t result;
96867
96868   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96869   {
96870     try {
96871       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96872     } catch (std::out_of_range& e) {
96873       {
96874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96875       };
96876     } catch (std::exception& e) {
96877       {
96878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96879       };
96880     } catch (Dali::DaliException e) {
96881       {
96882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96883       };
96884     } catch (...) {
96885       {
96886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96887       };
96888     }
96889   }
96890
96891   jresult = (unsigned long)result;
96892   return jresult;
96893 }
96894
96895
96896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96897   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96898   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96899
96900   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96901   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96902   {
96903     try {
96904       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96905     } catch (std::out_of_range& e) {
96906       {
96907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96908       };
96909     } catch (std::exception& e) {
96910       {
96911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96912       };
96913     } catch (Dali::DaliException e) {
96914       {
96915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96916       };
96917     } catch (...) {
96918       {
96919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96920       };
96921     }
96922   }
96923
96924 }
96925
96926
96927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96928   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96929   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96930
96931   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96932   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96933   {
96934     try {
96935       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96936     } catch (std::out_of_range& e) {
96937       {
96938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96939       };
96940     } catch (std::exception& e) {
96941       {
96942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96943       };
96944     } catch (Dali::DaliException e) {
96945       {
96946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96947       };
96948     } catch (...) {
96949       {
96950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96951       };
96952     }
96953   }
96954
96955 }
96956
96957
96958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96959   unsigned int jresult ;
96960   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96961   Dali::Toolkit::Button arg2 ;
96962   Dali::Toolkit::Button *argp2 ;
96963   bool result;
96964
96965   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96966   argp2 = (Dali::Toolkit::Button *)jarg2;
96967   if (!argp2) {
96968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96969     return 0;
96970   }
96971   arg2 = *argp2;
96972   {
96973     try {
96974       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96975     } catch (std::out_of_range& e) {
96976       {
96977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96978       };
96979     } catch (std::exception& e) {
96980       {
96981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96982       };
96983     } catch (Dali::DaliException e) {
96984       {
96985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96986       };
96987     } catch (...) {
96988       {
96989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96990       };
96991     }
96992   }
96993
96994   jresult = result;
96995   return jresult;
96996 }
96997
96998
96999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
97000   void * jresult ;
97001   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
97002
97003   {
97004     try {
97005       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
97006     } catch (std::out_of_range& e) {
97007       {
97008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97009       };
97010     } catch (std::exception& e) {
97011       {
97012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97013       };
97014     } catch (Dali::DaliException e) {
97015       {
97016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97017       };
97018     } catch (...) {
97019       {
97020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97021       };
97022     }
97023   }
97024
97025   jresult = (void *)result;
97026   return jresult;
97027 }
97028
97029
97030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
97031   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97032
97033   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97034   {
97035     try {
97036       delete arg1;
97037     } catch (std::out_of_range& e) {
97038       {
97039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97040       };
97041     } catch (std::exception& e) {
97042       {
97043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97044       };
97045     } catch (Dali::DaliException e) {
97046       {
97047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97048       };
97049     } catch (...) {
97050       {
97051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97052       };
97053     }
97054   }
97055
97056 }
97057
97058
97059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
97060   unsigned int jresult ;
97061   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97062   bool result;
97063
97064   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97065   {
97066     try {
97067       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97068     } catch (std::out_of_range& e) {
97069       {
97070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97071       };
97072     } catch (std::exception& e) {
97073       {
97074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97075       };
97076     } catch (Dali::DaliException e) {
97077       {
97078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97079       };
97080     } catch (...) {
97081       {
97082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97083       };
97084     }
97085   }
97086
97087   jresult = result;
97088   return jresult;
97089 }
97090
97091
97092 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97093   unsigned long jresult ;
97094   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97095   std::size_t result;
97096
97097   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97098   {
97099     try {
97100       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97101     } catch (std::out_of_range& e) {
97102       {
97103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97104       };
97105     } catch (std::exception& e) {
97106       {
97107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97108       };
97109     } catch (Dali::DaliException e) {
97110       {
97111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97112       };
97113     } catch (...) {
97114       {
97115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97116       };
97117     }
97118   }
97119
97120   jresult = (unsigned long)result;
97121   return jresult;
97122 }
97123
97124
97125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97126   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97127   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97128
97129   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97130   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97131   {
97132     try {
97133       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97134     } catch (std::out_of_range& e) {
97135       {
97136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97137       };
97138     } catch (std::exception& e) {
97139       {
97140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97141       };
97142     } catch (Dali::DaliException e) {
97143       {
97144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97145       };
97146     } catch (...) {
97147       {
97148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97149       };
97150     }
97151   }
97152
97153 }
97154
97155
97156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97157   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97158   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97159
97160   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97161   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97162   {
97163     try {
97164       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97165     } catch (std::out_of_range& e) {
97166       {
97167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97168       };
97169     } catch (std::exception& e) {
97170       {
97171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97172       };
97173     } catch (Dali::DaliException e) {
97174       {
97175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97176       };
97177     } catch (...) {
97178       {
97179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97180       };
97181     }
97182   }
97183
97184 }
97185
97186
97187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97188   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97189   Dali::Toolkit::GaussianBlurView arg2 ;
97190   Dali::Toolkit::GaussianBlurView *argp2 ;
97191
97192   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97193   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97194   if (!argp2) {
97195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97196     return ;
97197   }
97198   arg2 = *argp2;
97199   {
97200     try {
97201       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
97202     } catch (std::out_of_range& e) {
97203       {
97204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97205       };
97206     } catch (std::exception& e) {
97207       {
97208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97209       };
97210     } catch (Dali::DaliException e) {
97211       {
97212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97213       };
97214     } catch (...) {
97215       {
97216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97217       };
97218     }
97219   }
97220
97221 }
97222
97223
97224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
97225   void * jresult ;
97226   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97227
97228   {
97229     try {
97230       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97231     } catch (std::out_of_range& e) {
97232       {
97233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97234       };
97235     } catch (std::exception& e) {
97236       {
97237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97238       };
97239     } catch (Dali::DaliException e) {
97240       {
97241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97242       };
97243     } catch (...) {
97244       {
97245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97246       };
97247     }
97248   }
97249
97250   jresult = (void *)result;
97251   return jresult;
97252 }
97253
97254
97255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97256   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97257
97258   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97259   {
97260     try {
97261       delete arg1;
97262     } catch (std::out_of_range& e) {
97263       {
97264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97265       };
97266     } catch (std::exception& e) {
97267       {
97268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97269       };
97270     } catch (Dali::DaliException e) {
97271       {
97272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97273       };
97274     } catch (...) {
97275       {
97276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97277       };
97278     }
97279   }
97280
97281 }
97282
97283
97284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97285   unsigned int jresult ;
97286   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97287   bool result;
97288
97289   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97290   {
97291     try {
97292       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);
97293     } catch (std::out_of_range& e) {
97294       {
97295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97296       };
97297     } catch (std::exception& e) {
97298       {
97299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97300       };
97301     } catch (Dali::DaliException e) {
97302       {
97303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97304       };
97305     } catch (...) {
97306       {
97307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97308       };
97309     }
97310   }
97311
97312   jresult = result;
97313   return jresult;
97314 }
97315
97316
97317 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97318   unsigned long jresult ;
97319   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97320   std::size_t result;
97321
97322   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97323   {
97324     try {
97325       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);
97326     } catch (std::out_of_range& e) {
97327       {
97328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97329       };
97330     } catch (std::exception& e) {
97331       {
97332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97333       };
97334     } catch (Dali::DaliException e) {
97335       {
97336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97337       };
97338     } catch (...) {
97339       {
97340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97341       };
97342     }
97343   }
97344
97345   jresult = (unsigned long)result;
97346   return jresult;
97347 }
97348
97349
97350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97351   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97352   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97353
97354   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97355   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97356   {
97357     try {
97358       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97359     } catch (std::out_of_range& e) {
97360       {
97361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97362       };
97363     } catch (std::exception& e) {
97364       {
97365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97366       };
97367     } catch (Dali::DaliException e) {
97368       {
97369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97370       };
97371     } catch (...) {
97372       {
97373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97374       };
97375     }
97376   }
97377
97378 }
97379
97380
97381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97382   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97383   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97384
97385   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97386   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97387   {
97388     try {
97389       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97390     } catch (std::out_of_range& e) {
97391       {
97392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97393       };
97394     } catch (std::exception& e) {
97395       {
97396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97397       };
97398     } catch (Dali::DaliException e) {
97399       {
97400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97401       };
97402     } catch (...) {
97403       {
97404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97405       };
97406     }
97407   }
97408
97409 }
97410
97411
97412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97413   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97414   Dali::Toolkit::PageTurnView arg2 ;
97415   unsigned int arg3 ;
97416   bool arg4 ;
97417   Dali::Toolkit::PageTurnView *argp2 ;
97418
97419   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97420   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97421   if (!argp2) {
97422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97423     return ;
97424   }
97425   arg2 = *argp2;
97426   arg3 = (unsigned int)jarg3;
97427   arg4 = jarg4 ? true : false;
97428   {
97429     try {
97430       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97431     } catch (std::out_of_range& e) {
97432       {
97433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97434       };
97435     } catch (std::exception& e) {
97436       {
97437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97438       };
97439     } catch (Dali::DaliException e) {
97440       {
97441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97442       };
97443     } catch (...) {
97444       {
97445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97446       };
97447     }
97448   }
97449
97450 }
97451
97452
97453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97454   void * jresult ;
97455   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97456
97457   {
97458     try {
97459       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97460     } catch (std::out_of_range& e) {
97461       {
97462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97463       };
97464     } catch (std::exception& e) {
97465       {
97466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97467       };
97468     } catch (Dali::DaliException e) {
97469       {
97470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97471       };
97472     } catch (...) {
97473       {
97474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97475       };
97476     }
97477   }
97478
97479   jresult = (void *)result;
97480   return jresult;
97481 }
97482
97483
97484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97485   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97486
97487   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97488   {
97489     try {
97490       delete arg1;
97491     } catch (std::out_of_range& e) {
97492       {
97493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97494       };
97495     } catch (std::exception& e) {
97496       {
97497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97498       };
97499     } catch (Dali::DaliException e) {
97500       {
97501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97502       };
97503     } catch (...) {
97504       {
97505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97506       };
97507     }
97508   }
97509
97510 }
97511
97512
97513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97514   unsigned int jresult ;
97515   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97516   bool result;
97517
97518   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97519   {
97520     try {
97521       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97522     } catch (std::out_of_range& e) {
97523       {
97524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97525       };
97526     } catch (std::exception& e) {
97527       {
97528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97529       };
97530     } catch (Dali::DaliException e) {
97531       {
97532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97533       };
97534     } catch (...) {
97535       {
97536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97537       };
97538     }
97539   }
97540
97541   jresult = result;
97542   return jresult;
97543 }
97544
97545
97546 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97547   unsigned long jresult ;
97548   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97549   std::size_t result;
97550
97551   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97552   {
97553     try {
97554       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97555     } catch (std::out_of_range& e) {
97556       {
97557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97558       };
97559     } catch (std::exception& e) {
97560       {
97561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97562       };
97563     } catch (Dali::DaliException e) {
97564       {
97565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97566       };
97567     } catch (...) {
97568       {
97569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97570       };
97571     }
97572   }
97573
97574   jresult = (unsigned long)result;
97575   return jresult;
97576 }
97577
97578
97579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97580   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97581   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97582
97583   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97584   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97585   {
97586     try {
97587       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97588     } catch (std::out_of_range& e) {
97589       {
97590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97591       };
97592     } catch (std::exception& e) {
97593       {
97594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97595       };
97596     } catch (Dali::DaliException e) {
97597       {
97598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97599       };
97600     } catch (...) {
97601       {
97602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97603       };
97604     }
97605   }
97606
97607 }
97608
97609
97610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97611   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97612   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97613
97614   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97615   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97616   {
97617     try {
97618       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97619     } catch (std::out_of_range& e) {
97620       {
97621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97622       };
97623     } catch (std::exception& e) {
97624       {
97625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97626       };
97627     } catch (Dali::DaliException e) {
97628       {
97629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97630       };
97631     } catch (...) {
97632       {
97633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97634       };
97635     }
97636   }
97637
97638 }
97639
97640
97641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97642   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97643   Dali::Toolkit::PageTurnView arg2 ;
97644   Dali::Toolkit::PageTurnView *argp2 ;
97645
97646   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97647   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97648   if (!argp2) {
97649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97650     return ;
97651   }
97652   arg2 = *argp2;
97653   {
97654     try {
97655       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97656     } catch (std::out_of_range& e) {
97657       {
97658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97659       };
97660     } catch (std::exception& e) {
97661       {
97662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97663       };
97664     } catch (Dali::DaliException e) {
97665       {
97666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97667       };
97668     } catch (...) {
97669       {
97670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97671       };
97672     }
97673   }
97674
97675 }
97676
97677
97678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97679   void * jresult ;
97680   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97681
97682   {
97683     try {
97684       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97685     } catch (std::out_of_range& e) {
97686       {
97687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97688       };
97689     } catch (std::exception& e) {
97690       {
97691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97692       };
97693     } catch (Dali::DaliException e) {
97694       {
97695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97696       };
97697     } catch (...) {
97698       {
97699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97700       };
97701     }
97702   }
97703
97704   jresult = (void *)result;
97705   return jresult;
97706 }
97707
97708
97709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97710   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97711
97712   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97713   {
97714     try {
97715       delete arg1;
97716     } catch (std::out_of_range& e) {
97717       {
97718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97719       };
97720     } catch (std::exception& e) {
97721       {
97722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97723       };
97724     } catch (Dali::DaliException e) {
97725       {
97726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97727       };
97728     } catch (...) {
97729       {
97730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97731       };
97732     }
97733   }
97734
97735 }
97736
97737
97738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97739   unsigned int jresult ;
97740   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97741   bool result;
97742
97743   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97744   {
97745     try {
97746       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);
97747     } catch (std::out_of_range& e) {
97748       {
97749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97750       };
97751     } catch (std::exception& e) {
97752       {
97753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97754       };
97755     } catch (Dali::DaliException e) {
97756       {
97757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97758       };
97759     } catch (...) {
97760       {
97761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97762       };
97763     }
97764   }
97765
97766   jresult = result;
97767   return jresult;
97768 }
97769
97770
97771 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97772   unsigned long jresult ;
97773   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97774   std::size_t result;
97775
97776   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97777   {
97778     try {
97779       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);
97780     } catch (std::out_of_range& e) {
97781       {
97782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97783       };
97784     } catch (std::exception& e) {
97785       {
97786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97787       };
97788     } catch (Dali::DaliException e) {
97789       {
97790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97791       };
97792     } catch (...) {
97793       {
97794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97795       };
97796     }
97797   }
97798
97799   jresult = (unsigned long)result;
97800   return jresult;
97801 }
97802
97803
97804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97805   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97806   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97807
97808   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97809   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97810   {
97811     try {
97812       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97813     } catch (std::out_of_range& e) {
97814       {
97815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97816       };
97817     } catch (std::exception& e) {
97818       {
97819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97820       };
97821     } catch (Dali::DaliException e) {
97822       {
97823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97824       };
97825     } catch (...) {
97826       {
97827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97828       };
97829     }
97830   }
97831
97832 }
97833
97834
97835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97836   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97837   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97838
97839   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97840   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97841   {
97842     try {
97843       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97844     } catch (std::out_of_range& e) {
97845       {
97846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97847       };
97848     } catch (std::exception& e) {
97849       {
97850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97851       };
97852     } catch (Dali::DaliException e) {
97853       {
97854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97855       };
97856     } catch (...) {
97857       {
97858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97859       };
97860     }
97861   }
97862
97863 }
97864
97865
97866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97867   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97868   Dali::Toolkit::ProgressBar arg2 ;
97869   float arg3 ;
97870   float arg4 ;
97871   Dali::Toolkit::ProgressBar *argp2 ;
97872
97873   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97874   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97875   if (!argp2) {
97876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97877     return ;
97878   }
97879   arg2 = *argp2;
97880   arg3 = (float)jarg3;
97881   arg4 = (float)jarg4;
97882   {
97883     try {
97884       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97885     } catch (std::out_of_range& e) {
97886       {
97887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97888       };
97889     } catch (std::exception& e) {
97890       {
97891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97892       };
97893     } catch (Dali::DaliException e) {
97894       {
97895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97896       };
97897     } catch (...) {
97898       {
97899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97900       };
97901     }
97902   }
97903
97904 }
97905
97906
97907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97908   void * jresult ;
97909   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97910
97911   {
97912     try {
97913       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97914     } catch (std::out_of_range& e) {
97915       {
97916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97917       };
97918     } catch (std::exception& e) {
97919       {
97920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97921       };
97922     } catch (Dali::DaliException e) {
97923       {
97924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97925       };
97926     } catch (...) {
97927       {
97928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97929       };
97930     }
97931   }
97932
97933   jresult = (void *)result;
97934   return jresult;
97935 }
97936
97937
97938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97939   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97940
97941   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97942   {
97943     try {
97944       delete arg1;
97945     } catch (std::out_of_range& e) {
97946       {
97947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97948       };
97949     } catch (std::exception& e) {
97950       {
97951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97952       };
97953     } catch (Dali::DaliException e) {
97954       {
97955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97956       };
97957     } catch (...) {
97958       {
97959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97960       };
97961     }
97962   }
97963
97964 }
97965
97966
97967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97968   unsigned int jresult ;
97969   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97970   bool result;
97971
97972   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97973   {
97974     try {
97975       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);
97976     } catch (std::out_of_range& e) {
97977       {
97978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97979       };
97980     } catch (std::exception& e) {
97981       {
97982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97983       };
97984     } catch (Dali::DaliException e) {
97985       {
97986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97987       };
97988     } catch (...) {
97989       {
97990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97991       };
97992     }
97993   }
97994
97995   jresult = result;
97996   return jresult;
97997 }
97998
97999
98000 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
98001   unsigned long jresult ;
98002   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98003   std::size_t result;
98004
98005   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98006   {
98007     try {
98008       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);
98009     } catch (std::out_of_range& e) {
98010       {
98011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98012       };
98013     } catch (std::exception& e) {
98014       {
98015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98016       };
98017     } catch (Dali::DaliException e) {
98018       {
98019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98020       };
98021     } catch (...) {
98022       {
98023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98024       };
98025     }
98026   }
98027
98028   jresult = (unsigned long)result;
98029   return jresult;
98030 }
98031
98032
98033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
98034   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98035   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98036
98037   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98038   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98039   {
98040     try {
98041       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98042     } catch (std::out_of_range& e) {
98043       {
98044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98045       };
98046     } catch (std::exception& e) {
98047       {
98048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98049       };
98050     } catch (Dali::DaliException e) {
98051       {
98052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98053       };
98054     } catch (...) {
98055       {
98056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98057       };
98058     }
98059   }
98060
98061 }
98062
98063
98064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98065   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98066   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98067
98068   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98069   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98070   {
98071     try {
98072       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98073     } catch (std::out_of_range& e) {
98074       {
98075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98076       };
98077     } catch (std::exception& e) {
98078       {
98079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98080       };
98081     } catch (Dali::DaliException e) {
98082       {
98083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98084       };
98085     } catch (...) {
98086       {
98087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98088       };
98089     }
98090   }
98091
98092 }
98093
98094
98095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98096   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98097   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98098
98099   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98100   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98101   if (!arg2) {
98102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98103     return ;
98104   }
98105   {
98106     try {
98107       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98108     } catch (std::out_of_range& e) {
98109       {
98110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98111       };
98112     } catch (std::exception& e) {
98113       {
98114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98115       };
98116     } catch (Dali::DaliException e) {
98117       {
98118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98119       };
98120     } catch (...) {
98121       {
98122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98123       };
98124     }
98125   }
98126
98127 }
98128
98129
98130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98131   void * jresult ;
98132   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98133
98134   {
98135     try {
98136       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98137     } catch (std::out_of_range& e) {
98138       {
98139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98140       };
98141     } catch (std::exception& e) {
98142       {
98143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98144       };
98145     } catch (Dali::DaliException e) {
98146       {
98147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98148       };
98149     } catch (...) {
98150       {
98151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98152       };
98153     }
98154   }
98155
98156   jresult = (void *)result;
98157   return jresult;
98158 }
98159
98160
98161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98162   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98163
98164   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98165   {
98166     try {
98167       delete arg1;
98168     } catch (std::out_of_range& e) {
98169       {
98170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98171       };
98172     } catch (std::exception& e) {
98173       {
98174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98175       };
98176     } catch (Dali::DaliException e) {
98177       {
98178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98179       };
98180     } catch (...) {
98181       {
98182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98183       };
98184     }
98185   }
98186
98187 }
98188
98189
98190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98191   unsigned int jresult ;
98192   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98193   bool result;
98194
98195   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98196   {
98197     try {
98198       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98199     } catch (std::out_of_range& e) {
98200       {
98201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98202       };
98203     } catch (std::exception& e) {
98204       {
98205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98206       };
98207     } catch (Dali::DaliException e) {
98208       {
98209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98210       };
98211     } catch (...) {
98212       {
98213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98214       };
98215     }
98216   }
98217
98218   jresult = result;
98219   return jresult;
98220 }
98221
98222
98223 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98224   unsigned long jresult ;
98225   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98226   std::size_t result;
98227
98228   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98229   {
98230     try {
98231       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98232     } catch (std::out_of_range& e) {
98233       {
98234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98235       };
98236     } catch (std::exception& e) {
98237       {
98238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98239       };
98240     } catch (Dali::DaliException e) {
98241       {
98242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98243       };
98244     } catch (...) {
98245       {
98246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98247       };
98248     }
98249   }
98250
98251   jresult = (unsigned long)result;
98252   return jresult;
98253 }
98254
98255
98256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98257   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98258   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98259
98260   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98261   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98262   {
98263     try {
98264       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98265     } catch (std::out_of_range& e) {
98266       {
98267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98268       };
98269     } catch (std::exception& e) {
98270       {
98271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98272       };
98273     } catch (Dali::DaliException e) {
98274       {
98275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98276       };
98277     } catch (...) {
98278       {
98279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98280       };
98281     }
98282   }
98283
98284 }
98285
98286
98287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98288   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98289   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98290
98291   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98292   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98293   {
98294     try {
98295       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98296     } catch (std::out_of_range& e) {
98297       {
98298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98299       };
98300     } catch (std::exception& e) {
98301       {
98302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98303       };
98304     } catch (Dali::DaliException e) {
98305       {
98306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98307       };
98308     } catch (...) {
98309       {
98310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98311       };
98312     }
98313   }
98314
98315 }
98316
98317
98318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98319   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98320   Dali::Vector2 *arg2 = 0 ;
98321
98322   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98323   arg2 = (Dali::Vector2 *)jarg2;
98324   if (!arg2) {
98325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98326     return ;
98327   }
98328   {
98329     try {
98330       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98331     } catch (std::out_of_range& e) {
98332       {
98333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98334       };
98335     } catch (std::exception& e) {
98336       {
98337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98338       };
98339     } catch (Dali::DaliException e) {
98340       {
98341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98342       };
98343     } catch (...) {
98344       {
98345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98346       };
98347     }
98348   }
98349
98350 }
98351
98352
98353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98354   void * jresult ;
98355   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98356
98357   {
98358     try {
98359       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98360     } catch (std::out_of_range& e) {
98361       {
98362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98363       };
98364     } catch (std::exception& e) {
98365       {
98366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98367       };
98368     } catch (Dali::DaliException e) {
98369       {
98370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98371       };
98372     } catch (...) {
98373       {
98374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98375       };
98376     }
98377   }
98378
98379   jresult = (void *)result;
98380   return jresult;
98381 }
98382
98383
98384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98385   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98386
98387   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98388   {
98389     try {
98390       delete arg1;
98391     } catch (std::out_of_range& e) {
98392       {
98393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98394       };
98395     } catch (std::exception& e) {
98396       {
98397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98398       };
98399     } catch (Dali::DaliException e) {
98400       {
98401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98402       };
98403     } catch (...) {
98404       {
98405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98406       };
98407     }
98408   }
98409
98410 }
98411
98412
98413
98414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98415   unsigned int jresult ;
98416   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98417   bool result;
98418
98419   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98420   {
98421     try {
98422       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);
98423     } catch (std::out_of_range& e) {
98424       {
98425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98426       };
98427     } catch (std::exception& e) {
98428       {
98429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98430       };
98431     } catch (Dali::DaliException e) {
98432       {
98433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98434       };
98435     } catch (...) {
98436       {
98437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98438       };
98439     }
98440   }
98441
98442   jresult = result;
98443   return jresult;
98444 }
98445
98446
98447 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98448   unsigned long jresult ;
98449   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98450   std::size_t result;
98451
98452   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98453   {
98454     try {
98455       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);
98456     } catch (std::out_of_range& e) {
98457       {
98458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98459       };
98460     } catch (std::exception& e) {
98461       {
98462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98463       };
98464     } catch (Dali::DaliException e) {
98465       {
98466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98467       };
98468     } catch (...) {
98469       {
98470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98471       };
98472     }
98473   }
98474
98475   jresult = (unsigned long)result;
98476   return jresult;
98477 }
98478
98479
98480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98481   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98482   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98483
98484   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98485   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98486   {
98487     try {
98488       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98489     } catch (std::out_of_range& e) {
98490       {
98491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98492       };
98493     } catch (std::exception& e) {
98494       {
98495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98496       };
98497     } catch (Dali::DaliException e) {
98498       {
98499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98500       };
98501     } catch (...) {
98502       {
98503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98504       };
98505     }
98506   }
98507
98508 }
98509
98510
98511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98512   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98513   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98514
98515   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98516   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98517   {
98518     try {
98519       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98520     } catch (std::out_of_range& e) {
98521       {
98522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98523       };
98524     } catch (std::exception& e) {
98525       {
98526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98527       };
98528     } catch (Dali::DaliException e) {
98529       {
98530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98531       };
98532     } catch (...) {
98533       {
98534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98535       };
98536     }
98537   }
98538
98539 }
98540
98541
98542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98543   unsigned int jresult ;
98544   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98545   Dali::Toolkit::Control arg2 ;
98546   Dali::KeyEvent *arg3 = 0 ;
98547   Dali::Toolkit::Control *argp2 ;
98548   bool result;
98549
98550   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98551   argp2 = (Dali::Toolkit::Control *)jarg2;
98552   if (!argp2) {
98553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98554     return 0;
98555   }
98556   arg2 = *argp2;
98557   arg3 = (Dali::KeyEvent *)jarg3;
98558   if (!arg3) {
98559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98560     return 0;
98561   }
98562   {
98563     try {
98564       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);
98565     } catch (std::out_of_range& e) {
98566       {
98567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98568       };
98569     } catch (std::exception& e) {
98570       {
98571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98572       };
98573     } catch (Dali::DaliException e) {
98574       {
98575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98576       };
98577     } catch (...) {
98578       {
98579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98580       };
98581     }
98582   }
98583
98584   jresult = result;
98585   return jresult;
98586 }
98587
98588
98589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98590   void * jresult ;
98591   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98592
98593   {
98594     try {
98595       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98596     } catch (std::out_of_range& e) {
98597       {
98598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98599       };
98600     } catch (std::exception& e) {
98601       {
98602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98603       };
98604     } catch (Dali::DaliException e) {
98605       {
98606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98607       };
98608     } catch (...) {
98609       {
98610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98611       };
98612     }
98613   }
98614
98615   jresult = (void *)result;
98616   return jresult;
98617 }
98618
98619
98620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98621   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98622
98623   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98624   {
98625     try {
98626       delete arg1;
98627     } catch (std::out_of_range& e) {
98628       {
98629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98630       };
98631     } catch (std::exception& e) {
98632       {
98633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98634       };
98635     } catch (Dali::DaliException e) {
98636       {
98637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98638       };
98639     } catch (...) {
98640       {
98641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98642       };
98643     }
98644   }
98645
98646 }
98647
98648
98649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98650   unsigned int jresult ;
98651   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98652   bool result;
98653
98654   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98655   {
98656     try {
98657       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98658     } catch (std::out_of_range& e) {
98659       {
98660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98661       };
98662     } catch (std::exception& e) {
98663       {
98664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98665       };
98666     } catch (Dali::DaliException e) {
98667       {
98668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98669       };
98670     } catch (...) {
98671       {
98672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98673       };
98674     }
98675   }
98676
98677   jresult = result;
98678   return jresult;
98679 }
98680
98681
98682 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98683   unsigned long jresult ;
98684   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98685   std::size_t result;
98686
98687   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98688   {
98689     try {
98690       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98691     } catch (std::out_of_range& e) {
98692       {
98693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98694       };
98695     } catch (std::exception& e) {
98696       {
98697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98698       };
98699     } catch (Dali::DaliException e) {
98700       {
98701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98702       };
98703     } catch (...) {
98704       {
98705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98706       };
98707     }
98708   }
98709
98710   jresult = (unsigned long)result;
98711   return jresult;
98712 }
98713
98714
98715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98716   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98717   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98718
98719   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98720   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98721   {
98722     try {
98723       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98724     } catch (std::out_of_range& e) {
98725       {
98726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98727       };
98728     } catch (std::exception& e) {
98729       {
98730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98731       };
98732     } catch (Dali::DaliException e) {
98733       {
98734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98735       };
98736     } catch (...) {
98737       {
98738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98739       };
98740     }
98741   }
98742
98743 }
98744
98745
98746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98747   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98748   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98749
98750   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98751   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98752   {
98753     try {
98754       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98755     } catch (std::out_of_range& e) {
98756       {
98757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98758       };
98759     } catch (std::exception& e) {
98760       {
98761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98762       };
98763     } catch (Dali::DaliException e) {
98764       {
98765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98766       };
98767     } catch (...) {
98768       {
98769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98770       };
98771     }
98772   }
98773
98774 }
98775
98776
98777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98778   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98779   Dali::Toolkit::Control arg2 ;
98780   Dali::Toolkit::Control *argp2 ;
98781
98782   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98783   argp2 = (Dali::Toolkit::Control *)jarg2;
98784   if (!argp2) {
98785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98786     return ;
98787   }
98788   arg2 = *argp2;
98789   {
98790     try {
98791       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98792     } catch (std::out_of_range& e) {
98793       {
98794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98795       };
98796     } catch (std::exception& e) {
98797       {
98798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98799       };
98800     } catch (Dali::DaliException e) {
98801       {
98802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98803       };
98804     } catch (...) {
98805       {
98806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98807       };
98808     }
98809   }
98810
98811 }
98812
98813
98814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98815   void * jresult ;
98816   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98817
98818   {
98819     try {
98820       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98821     } catch (std::out_of_range& e) {
98822       {
98823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98824       };
98825     } catch (std::exception& e) {
98826       {
98827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98828       };
98829     } catch (Dali::DaliException e) {
98830       {
98831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98832       };
98833     } catch (...) {
98834       {
98835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98836       };
98837     }
98838   }
98839
98840   jresult = (void *)result;
98841   return jresult;
98842 }
98843
98844
98845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98846   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98847
98848   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98849   {
98850     try {
98851       delete arg1;
98852     } catch (std::out_of_range& e) {
98853       {
98854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98855       };
98856     } catch (std::exception& e) {
98857       {
98858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98859       };
98860     } catch (Dali::DaliException e) {
98861       {
98862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98863       };
98864     } catch (...) {
98865       {
98866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98867       };
98868     }
98869   }
98870
98871 }
98872
98873
98874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98875   unsigned int jresult ;
98876   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98877   bool result;
98878
98879   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98880   {
98881     try {
98882       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98883     } catch (std::out_of_range& e) {
98884       {
98885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98886       };
98887     } catch (std::exception& e) {
98888       {
98889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98890       };
98891     } catch (Dali::DaliException e) {
98892       {
98893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98894       };
98895     } catch (...) {
98896       {
98897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98898       };
98899     }
98900   }
98901
98902   jresult = result;
98903   return jresult;
98904 }
98905
98906
98907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98908   unsigned long jresult ;
98909   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98910   std::size_t result;
98911
98912   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98913   {
98914     try {
98915       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98916     } catch (std::out_of_range& e) {
98917       {
98918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98919       };
98920     } catch (std::exception& e) {
98921       {
98922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98923       };
98924     } catch (Dali::DaliException e) {
98925       {
98926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98927       };
98928     } catch (...) {
98929       {
98930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98931       };
98932     }
98933   }
98934
98935   jresult = (unsigned long)result;
98936   return jresult;
98937 }
98938
98939
98940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98941   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98942   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98943
98944   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98945   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98946   {
98947     try {
98948       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98949     } catch (std::out_of_range& e) {
98950       {
98951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98952       };
98953     } catch (std::exception& e) {
98954       {
98955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98956       };
98957     } catch (Dali::DaliException e) {
98958       {
98959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98960       };
98961     } catch (...) {
98962       {
98963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98964       };
98965     }
98966   }
98967
98968 }
98969
98970
98971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98972   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98973   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98974
98975   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98976   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98977   {
98978     try {
98979       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98980     } catch (std::out_of_range& e) {
98981       {
98982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98983       };
98984     } catch (std::exception& e) {
98985       {
98986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98987       };
98988     } catch (Dali::DaliException e) {
98989       {
98990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98991       };
98992     } catch (...) {
98993       {
98994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98995       };
98996     }
98997   }
98998
98999 }
99000
99001
99002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
99003   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99004   Dali::Toolkit::VideoView *arg2 = 0 ;
99005
99006   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99007   arg2 = (Dali::Toolkit::VideoView *)jarg2;
99008   if (!arg2) {
99009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
99010     return ;
99011   }
99012   {
99013     try {
99014       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
99015     } catch (std::out_of_range& e) {
99016       {
99017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99018       };
99019     } catch (std::exception& e) {
99020       {
99021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99022       };
99023     } catch (Dali::DaliException e) {
99024       {
99025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99026       };
99027     } catch (...) {
99028       {
99029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99030       };
99031     }
99032   }
99033
99034 }
99035
99036
99037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
99038   void * jresult ;
99039   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
99040
99041   {
99042     try {
99043       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
99044     } catch (std::out_of_range& e) {
99045       {
99046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99047       };
99048     } catch (std::exception& e) {
99049       {
99050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99051       };
99052     } catch (Dali::DaliException e) {
99053       {
99054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99055       };
99056     } catch (...) {
99057       {
99058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99059       };
99060     }
99061   }
99062
99063   jresult = (void *)result;
99064   return jresult;
99065 }
99066
99067
99068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99069   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99070
99071   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99072   {
99073     try {
99074       delete arg1;
99075     } catch (std::out_of_range& e) {
99076       {
99077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99078       };
99079     } catch (std::exception& e) {
99080       {
99081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99082       };
99083     } catch (Dali::DaliException e) {
99084       {
99085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99086       };
99087     } catch (...) {
99088       {
99089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99090       };
99091     }
99092   }
99093
99094 }
99095
99096
99097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99098   unsigned int jresult ;
99099   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99100   bool result;
99101
99102   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99103   {
99104     try {
99105       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99106     } catch (std::out_of_range& e) {
99107       {
99108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99109       };
99110     } catch (std::exception& e) {
99111       {
99112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99113       };
99114     } catch (Dali::DaliException e) {
99115       {
99116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99117       };
99118     } catch (...) {
99119       {
99120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99121       };
99122     }
99123   }
99124
99125   jresult = result;
99126   return jresult;
99127 }
99128
99129
99130 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99131   unsigned long jresult ;
99132   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99133   std::size_t result;
99134
99135   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99136   {
99137     try {
99138       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99139     } catch (std::out_of_range& e) {
99140       {
99141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99142       };
99143     } catch (std::exception& e) {
99144       {
99145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99146       };
99147     } catch (Dali::DaliException e) {
99148       {
99149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99150       };
99151     } catch (...) {
99152       {
99153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99154       };
99155     }
99156   }
99157
99158   jresult = (unsigned long)result;
99159   return jresult;
99160 }
99161
99162
99163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99164   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99165   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99166
99167   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99168   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99169   {
99170     try {
99171       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99172     } catch (std::out_of_range& e) {
99173       {
99174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99175       };
99176     } catch (std::exception& e) {
99177       {
99178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99179       };
99180     } catch (Dali::DaliException e) {
99181       {
99182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99183       };
99184     } catch (...) {
99185       {
99186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99187       };
99188     }
99189   }
99190
99191 }
99192
99193
99194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99195   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99196   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99197
99198   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99199   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99200   {
99201     try {
99202       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99203     } catch (std::out_of_range& e) {
99204       {
99205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99206       };
99207     } catch (std::exception& e) {
99208       {
99209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99210       };
99211     } catch (Dali::DaliException e) {
99212       {
99213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99214       };
99215     } catch (...) {
99216       {
99217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99218       };
99219     }
99220   }
99221
99222 }
99223
99224
99225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99226   unsigned int jresult ;
99227   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99228   Dali::Toolkit::Slider arg2 ;
99229   float arg3 ;
99230   Dali::Toolkit::Slider *argp2 ;
99231   bool result;
99232
99233   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99234   argp2 = (Dali::Toolkit::Slider *)jarg2;
99235   if (!argp2) {
99236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99237     return 0;
99238   }
99239   arg2 = *argp2;
99240   arg3 = (float)jarg3;
99241   {
99242     try {
99243       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99244     } catch (std::out_of_range& e) {
99245       {
99246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99247       };
99248     } catch (std::exception& e) {
99249       {
99250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99251       };
99252     } catch (Dali::DaliException e) {
99253       {
99254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99255       };
99256     } catch (...) {
99257       {
99258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99259       };
99260     }
99261   }
99262
99263   jresult = result;
99264   return jresult;
99265 }
99266
99267
99268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99269   void * jresult ;
99270   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99271
99272   {
99273     try {
99274       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99275     } catch (std::out_of_range& e) {
99276       {
99277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99278       };
99279     } catch (std::exception& e) {
99280       {
99281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99282       };
99283     } catch (Dali::DaliException e) {
99284       {
99285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99286       };
99287     } catch (...) {
99288       {
99289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99290       };
99291     }
99292   }
99293
99294   jresult = (void *)result;
99295   return jresult;
99296 }
99297
99298
99299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99300   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99301
99302   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99303   {
99304     try {
99305       delete arg1;
99306     } catch (std::out_of_range& e) {
99307       {
99308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99309       };
99310     } catch (std::exception& e) {
99311       {
99312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99313       };
99314     } catch (Dali::DaliException e) {
99315       {
99316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99317       };
99318     } catch (...) {
99319       {
99320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99321       };
99322     }
99323   }
99324
99325 }
99326
99327
99328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99329   unsigned int jresult ;
99330   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99331   bool result;
99332
99333   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99334   {
99335     try {
99336       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99337     } catch (std::out_of_range& e) {
99338       {
99339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99340       };
99341     } catch (std::exception& e) {
99342       {
99343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99344       };
99345     } catch (Dali::DaliException e) {
99346       {
99347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99348       };
99349     } catch (...) {
99350       {
99351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99352       };
99353     }
99354   }
99355
99356   jresult = result;
99357   return jresult;
99358 }
99359
99360
99361 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99362   unsigned long jresult ;
99363   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99364   std::size_t result;
99365
99366   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99367   {
99368     try {
99369       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99370     } catch (std::out_of_range& e) {
99371       {
99372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99373       };
99374     } catch (std::exception& e) {
99375       {
99376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99377       };
99378     } catch (Dali::DaliException e) {
99379       {
99380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99381       };
99382     } catch (...) {
99383       {
99384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99385       };
99386     }
99387   }
99388
99389   jresult = (unsigned long)result;
99390   return jresult;
99391 }
99392
99393
99394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99395   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99396   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99397
99398   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99399   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99400   {
99401     try {
99402       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99403     } catch (std::out_of_range& e) {
99404       {
99405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99406       };
99407     } catch (std::exception& e) {
99408       {
99409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99410       };
99411     } catch (Dali::DaliException e) {
99412       {
99413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99414       };
99415     } catch (...) {
99416       {
99417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99418       };
99419     }
99420   }
99421
99422 }
99423
99424
99425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99426   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99427   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99428
99429   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99430   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99431   {
99432     try {
99433       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99434     } catch (std::out_of_range& e) {
99435       {
99436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99437       };
99438     } catch (std::exception& e) {
99439       {
99440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99441       };
99442     } catch (Dali::DaliException e) {
99443       {
99444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99445       };
99446     } catch (...) {
99447       {
99448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99449       };
99450     }
99451   }
99452
99453 }
99454
99455
99456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99457   unsigned int jresult ;
99458   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99459   Dali::Toolkit::Slider arg2 ;
99460   int arg3 ;
99461   Dali::Toolkit::Slider *argp2 ;
99462   bool result;
99463
99464   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99465   argp2 = (Dali::Toolkit::Slider *)jarg2;
99466   if (!argp2) {
99467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99468     return 0;
99469   }
99470   arg2 = *argp2;
99471   arg3 = (int)jarg3;
99472   {
99473     try {
99474       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99475     } catch (std::out_of_range& e) {
99476       {
99477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99478       };
99479     } catch (std::exception& e) {
99480       {
99481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99482       };
99483     } catch (Dali::DaliException e) {
99484       {
99485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99486       };
99487     } catch (...) {
99488       {
99489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99490       };
99491     }
99492   }
99493
99494   jresult = result;
99495   return jresult;
99496 }
99497
99498
99499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99500   void * jresult ;
99501   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99502
99503   {
99504     try {
99505       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99506     } catch (std::out_of_range& e) {
99507       {
99508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99509       };
99510     } catch (std::exception& e) {
99511       {
99512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99513       };
99514     } catch (Dali::DaliException e) {
99515       {
99516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99517       };
99518     } catch (...) {
99519       {
99520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99521       };
99522     }
99523   }
99524
99525   jresult = (void *)result;
99526   return jresult;
99527 }
99528
99529
99530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99531   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99532
99533   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99534   {
99535     try {
99536       delete arg1;
99537     } catch (std::out_of_range& e) {
99538       {
99539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99540       };
99541     } catch (std::exception& e) {
99542       {
99543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99544       };
99545     } catch (Dali::DaliException e) {
99546       {
99547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99548       };
99549     } catch (...) {
99550       {
99551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99552       };
99553     }
99554   }
99555
99556 }
99557
99558
99559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99560   void * jresult ;
99561   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99562
99563   {
99564     try {
99565       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99566     } catch (std::out_of_range& e) {
99567       {
99568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99569       };
99570     } catch (std::exception& e) {
99571       {
99572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99573       };
99574     } catch (Dali::DaliException e) {
99575       {
99576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99577       };
99578     } catch (...) {
99579       {
99580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99581       };
99582     }
99583   }
99584
99585   jresult = (void *)result;
99586   return jresult;
99587 }
99588
99589
99590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99591   void * jresult ;
99592   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99593   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99594
99595   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99596   {
99597     try {
99598       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99599     } catch (std::out_of_range& e) {
99600       {
99601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99602       };
99603     } catch (std::exception& e) {
99604       {
99605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99606       };
99607     } catch (Dali::DaliException e) {
99608       {
99609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99610       };
99611     } catch (...) {
99612       {
99613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99614       };
99615     }
99616   }
99617
99618   jresult = (void *)result;
99619   return jresult;
99620 }
99621
99622
99623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99624   void * jresult ;
99625   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99626   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99627
99628   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99629   if (!arg1) {
99630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99631     return 0;
99632   }
99633   {
99634     try {
99635       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99636     } catch (std::out_of_range& e) {
99637       {
99638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99639       };
99640     } catch (std::exception& e) {
99641       {
99642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99643       };
99644     } catch (Dali::DaliException e) {
99645       {
99646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99647       };
99648     } catch (...) {
99649       {
99650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99651       };
99652     }
99653   }
99654
99655   jresult = (void *)result;
99656   return jresult;
99657 }
99658
99659
99660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99661   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99662
99663   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99664   {
99665     try {
99666       delete arg1;
99667     } catch (std::out_of_range& e) {
99668       {
99669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99670       };
99671     } catch (std::exception& e) {
99672       {
99673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99674       };
99675     } catch (Dali::DaliException e) {
99676       {
99677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99678       };
99679     } catch (...) {
99680       {
99681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99682       };
99683     }
99684   }
99685
99686 }
99687
99688
99689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99690   void * jresult ;
99691   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99692   Dali::Toolkit::Ruler *result = 0 ;
99693
99694   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99695   {
99696     try {
99697       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99698     } catch (std::out_of_range& e) {
99699       {
99700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99701       };
99702     } catch (std::exception& e) {
99703       {
99704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99705       };
99706     } catch (Dali::DaliException e) {
99707       {
99708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99709       };
99710     } catch (...) {
99711       {
99712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99713       };
99714     }
99715   }
99716
99717   jresult = (void *)result;
99718   return jresult;
99719 }
99720
99721
99722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99723   void * jresult ;
99724   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99725   Dali::Toolkit::Ruler *result = 0 ;
99726
99727   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99728   {
99729     try {
99730       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99731     } catch (std::out_of_range& e) {
99732       {
99733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99734       };
99735     } catch (std::exception& e) {
99736       {
99737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99738       };
99739     } catch (Dali::DaliException e) {
99740       {
99741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99742       };
99743     } catch (...) {
99744       {
99745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99746       };
99747     }
99748   }
99749
99750   jresult = (void *)result;
99751   return jresult;
99752 }
99753
99754
99755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99756   void * jresult ;
99757   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99758   Dali::Toolkit::Ruler *result = 0 ;
99759
99760   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99761   {
99762     try {
99763       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99764     } catch (std::out_of_range& e) {
99765       {
99766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99767       };
99768     } catch (std::exception& e) {
99769       {
99770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99771       };
99772     } catch (Dali::DaliException e) {
99773       {
99774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99775       };
99776     } catch (...) {
99777       {
99778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99779       };
99780     }
99781   }
99782
99783   jresult = (void *)result;
99784   return jresult;
99785 }
99786
99787
99788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99789   void * jresult ;
99790   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99791   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99792   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99793
99794   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99795   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99796   if (!arg2) {
99797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99798     return 0;
99799   }
99800   {
99801     try {
99802       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99803     } catch (std::out_of_range& e) {
99804       {
99805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99806       };
99807     } catch (std::exception& e) {
99808       {
99809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99810       };
99811     } catch (Dali::DaliException e) {
99812       {
99813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99814       };
99815     } catch (...) {
99816       {
99817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99818       };
99819     }
99820   }
99821
99822   jresult = (void *)result;
99823   return jresult;
99824 }
99825
99826
99827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99828   void * jresult ;
99829   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99830   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99831   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99832
99833   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99834   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99835   {
99836     try {
99837       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99838     } catch (std::out_of_range& e) {
99839       {
99840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99841       };
99842     } catch (std::exception& e) {
99843       {
99844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99845       };
99846     } catch (Dali::DaliException e) {
99847       {
99848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99849       };
99850     } catch (...) {
99851       {
99852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99853       };
99854     }
99855   }
99856
99857   jresult = (void *)result;
99858   return jresult;
99859 }
99860
99861
99862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99863   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99864
99865   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99866   {
99867     try {
99868       (arg1)->Reset();
99869     } catch (std::out_of_range& e) {
99870       {
99871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99872       };
99873     } catch (std::exception& e) {
99874       {
99875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99876       };
99877     } catch (Dali::DaliException e) {
99878       {
99879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99880       };
99881     } catch (...) {
99882       {
99883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99884       };
99885     }
99886   }
99887
99888 }
99889
99890
99891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99892   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99893   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99894
99895   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99896   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99897   {
99898     try {
99899       (arg1)->Reset(arg2);
99900     } catch (std::out_of_range& e) {
99901       {
99902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99903       };
99904     } catch (std::exception& e) {
99905       {
99906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99907       };
99908     } catch (Dali::DaliException e) {
99909       {
99910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99911       };
99912     } catch (...) {
99913       {
99914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99915       };
99916     }
99917   }
99918
99919 }
99920
99921
99922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99923   void * jresult ;
99924   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99925   Dali::Toolkit::Ruler *result = 0 ;
99926
99927   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99928   {
99929     try {
99930       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99931     } catch (std::out_of_range& e) {
99932       {
99933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99934       };
99935     } catch (std::exception& e) {
99936       {
99937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99938       };
99939     } catch (Dali::DaliException e) {
99940       {
99941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99942       };
99943     } catch (...) {
99944       {
99945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99946       };
99947     }
99948   }
99949
99950   jresult = (void *)result;
99951   return jresult;
99952 }
99953
99954
99955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99956   float jresult ;
99957   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99958   float arg2 ;
99959   float arg3 ;
99960   float result;
99961
99962   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99963   arg2 = (float)jarg2;
99964   arg3 = (float)jarg3;
99965   {
99966     try {
99967       result = (float)(*arg1)->Snap(arg2,arg3);
99968     } catch (std::out_of_range& e) {
99969       {
99970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99971       };
99972     } catch (std::exception& e) {
99973       {
99974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99975       };
99976     } catch (Dali::DaliException e) {
99977       {
99978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99979       };
99980     } catch (...) {
99981       {
99982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99983       };
99984     }
99985   }
99986
99987   jresult = result;
99988   return jresult;
99989 }
99990
99991
99992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99993   float jresult ;
99994   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99995   float arg2 ;
99996   float result;
99997
99998   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99999   arg2 = (float)jarg2;
100000   {
100001     try {
100002       result = (float)(*arg1)->Snap(arg2);
100003     } catch (std::out_of_range& e) {
100004       {
100005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100006       };
100007     } catch (std::exception& e) {
100008       {
100009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100010       };
100011     } catch (Dali::DaliException e) {
100012       {
100013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100014       };
100015     } catch (...) {
100016       {
100017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100018       };
100019     }
100020   }
100021
100022   jresult = result;
100023   return jresult;
100024 }
100025
100026
100027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
100028   float jresult ;
100029   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100030   unsigned int arg2 ;
100031   unsigned int *arg3 = 0 ;
100032   bool arg4 ;
100033   float result;
100034
100035   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100036   arg2 = (unsigned int)jarg2;
100037   arg3 = (unsigned int *)jarg3;
100038   arg4 = jarg4 ? true : false;
100039   {
100040     try {
100041       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
100042     } catch (std::out_of_range& e) {
100043       {
100044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100045       };
100046     } catch (std::exception& e) {
100047       {
100048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100049       };
100050     } catch (Dali::DaliException e) {
100051       {
100052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100053       };
100054     } catch (...) {
100055       {
100056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100057       };
100058     }
100059   }
100060
100061   jresult = result;
100062   return jresult;
100063 }
100064
100065
100066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100067   unsigned int jresult ;
100068   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100069   float arg2 ;
100070   bool arg3 ;
100071   unsigned int result;
100072
100073   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100074   arg2 = (float)jarg2;
100075   arg3 = jarg3 ? true : false;
100076   {
100077     try {
100078       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
100079     } catch (std::out_of_range& e) {
100080       {
100081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100082       };
100083     } catch (std::exception& e) {
100084       {
100085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100086       };
100087     } catch (Dali::DaliException e) {
100088       {
100089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100090       };
100091     } catch (...) {
100092       {
100093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100094       };
100095     }
100096   }
100097
100098   jresult = result;
100099   return jresult;
100100 }
100101
100102
100103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
100104   unsigned int jresult ;
100105   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100106   unsigned int result;
100107
100108   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100109   {
100110     try {
100111       result = (unsigned int)(*arg1)->GetTotalPages();
100112     } catch (std::out_of_range& e) {
100113       {
100114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100115       };
100116     } catch (std::exception& e) {
100117       {
100118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100119       };
100120     } catch (Dali::DaliException e) {
100121       {
100122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100123       };
100124     } catch (...) {
100125       {
100126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100127       };
100128     }
100129   }
100130
100131   jresult = result;
100132   return jresult;
100133 }
100134
100135
100136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100137   int jresult ;
100138   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100139   Dali::Toolkit::Ruler::RulerType result;
100140
100141   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100142   {
100143     try {
100144       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100145     } catch (std::out_of_range& e) {
100146       {
100147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100148       };
100149     } catch (std::exception& e) {
100150       {
100151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100152       };
100153     } catch (Dali::DaliException e) {
100154       {
100155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100156       };
100157     } catch (...) {
100158       {
100159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100160       };
100161     }
100162   }
100163
100164   jresult = (int)result;
100165   return jresult;
100166 }
100167
100168
100169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100170   unsigned int jresult ;
100171   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100172   bool result;
100173
100174   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100175   {
100176     try {
100177       result = (bool)(*arg1)->IsEnabled();
100178     } catch (std::out_of_range& e) {
100179       {
100180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100181       };
100182     } catch (std::exception& e) {
100183       {
100184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100185       };
100186     } catch (Dali::DaliException e) {
100187       {
100188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100189       };
100190     } catch (...) {
100191       {
100192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100193       };
100194     }
100195   }
100196
100197   jresult = result;
100198   return jresult;
100199 }
100200
100201
100202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100203   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100204
100205   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100206   {
100207     try {
100208       (*arg1)->Enable();
100209     } catch (std::out_of_range& e) {
100210       {
100211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100212       };
100213     } catch (std::exception& e) {
100214       {
100215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100216       };
100217     } catch (Dali::DaliException e) {
100218       {
100219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100220       };
100221     } catch (...) {
100222       {
100223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100224       };
100225     }
100226   }
100227
100228 }
100229
100230
100231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100232   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100233
100234   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100235   {
100236     try {
100237       (*arg1)->Disable();
100238     } catch (std::out_of_range& e) {
100239       {
100240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100241       };
100242     } catch (std::exception& e) {
100243       {
100244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100245       };
100246     } catch (Dali::DaliException e) {
100247       {
100248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100249       };
100250     } catch (...) {
100251       {
100252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100253       };
100254     }
100255   }
100256
100257 }
100258
100259
100260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100261   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100262   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100263   Dali::Toolkit::RulerDomain *argp2 ;
100264
100265   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100266   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100267   if (!argp2) {
100268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100269     return ;
100270   }
100271   arg2 = *argp2;
100272   {
100273     try {
100274       (*arg1)->SetDomain(arg2);
100275     } catch (std::out_of_range& e) {
100276       {
100277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100278       };
100279     } catch (std::exception& e) {
100280       {
100281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100282       };
100283     } catch (Dali::DaliException e) {
100284       {
100285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100286       };
100287     } catch (...) {
100288       {
100289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100290       };
100291     }
100292   }
100293
100294 }
100295
100296
100297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100298   void * jresult ;
100299   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100300   Dali::Toolkit::RulerDomain *result = 0 ;
100301
100302   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100303   {
100304     try {
100305       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100306     } catch (std::out_of_range& e) {
100307       {
100308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100309       };
100310     } catch (std::exception& e) {
100311       {
100312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100313       };
100314     } catch (Dali::DaliException e) {
100315       {
100316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100317       };
100318     } catch (...) {
100319       {
100320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100321       };
100322     }
100323   }
100324
100325   jresult = (void *)result;
100326   return jresult;
100327 }
100328
100329
100330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100331   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100332
100333   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100334   {
100335     try {
100336       (*arg1)->DisableDomain();
100337     } catch (std::out_of_range& e) {
100338       {
100339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100340       };
100341     } catch (std::exception& e) {
100342       {
100343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100344       };
100345     } catch (Dali::DaliException e) {
100346       {
100347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100348       };
100349     } catch (...) {
100350       {
100351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100352       };
100353     }
100354   }
100355
100356 }
100357
100358
100359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100360   float jresult ;
100361   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100362   float arg2 ;
100363   float arg3 ;
100364   float arg4 ;
100365   float result;
100366
100367   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100368   arg2 = (float)jarg2;
100369   arg3 = (float)jarg3;
100370   arg4 = (float)jarg4;
100371   {
100372     try {
100373       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100374     } catch (std::out_of_range& e) {
100375       {
100376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100377       };
100378     } catch (std::exception& e) {
100379       {
100380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100381       };
100382     } catch (Dali::DaliException e) {
100383       {
100384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100385       };
100386     } catch (...) {
100387       {
100388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100389       };
100390     }
100391   }
100392
100393   jresult = result;
100394   return jresult;
100395 }
100396
100397
100398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100399   float jresult ;
100400   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100401   float arg2 ;
100402   float arg3 ;
100403   float result;
100404
100405   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100406   arg2 = (float)jarg2;
100407   arg3 = (float)jarg3;
100408   {
100409     try {
100410       result = (float)(*arg1)->Clamp(arg2,arg3);
100411     } catch (std::out_of_range& e) {
100412       {
100413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100414       };
100415     } catch (std::exception& e) {
100416       {
100417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100418       };
100419     } catch (Dali::DaliException e) {
100420       {
100421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100422       };
100423     } catch (...) {
100424       {
100425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100426       };
100427     }
100428   }
100429
100430   jresult = result;
100431   return jresult;
100432 }
100433
100434
100435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100436   float jresult ;
100437   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100438   float arg2 ;
100439   float result;
100440
100441   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100442   arg2 = (float)jarg2;
100443   {
100444     try {
100445       result = (float)(*arg1)->Clamp(arg2);
100446     } catch (std::out_of_range& e) {
100447       {
100448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100449       };
100450     } catch (std::exception& e) {
100451       {
100452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100453       };
100454     } catch (Dali::DaliException e) {
100455       {
100456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100457       };
100458     } catch (...) {
100459       {
100460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100461       };
100462     }
100463   }
100464
100465   jresult = result;
100466   return jresult;
100467 }
100468
100469
100470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100471   float jresult ;
100472   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100473   float arg2 ;
100474   float arg3 ;
100475   float arg4 ;
100476   Dali::Toolkit::ClampState *arg5 = 0 ;
100477   float result;
100478
100479   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100480   arg2 = (float)jarg2;
100481   arg3 = (float)jarg3;
100482   arg4 = (float)jarg4;
100483   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100484   if (!arg5) {
100485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100486     return 0;
100487   }
100488   {
100489     try {
100490       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100491     } catch (std::out_of_range& e) {
100492       {
100493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100494       };
100495     } catch (std::exception& e) {
100496       {
100497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100498       };
100499     } catch (Dali::DaliException e) {
100500       {
100501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100502       };
100503     } catch (...) {
100504       {
100505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100506       };
100507     }
100508   }
100509
100510   jresult = result;
100511   return jresult;
100512 }
100513
100514
100515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100516   float jresult ;
100517   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100518   float arg2 ;
100519   float arg3 ;
100520   float arg4 ;
100521   float arg5 ;
100522   float result;
100523
100524   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100525   arg2 = (float)jarg2;
100526   arg3 = (float)jarg3;
100527   arg4 = (float)jarg4;
100528   arg5 = (float)jarg5;
100529   {
100530     try {
100531       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100532     } catch (std::out_of_range& e) {
100533       {
100534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100535       };
100536     } catch (std::exception& e) {
100537       {
100538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100539       };
100540     } catch (Dali::DaliException e) {
100541       {
100542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100543       };
100544     } catch (...) {
100545       {
100546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100547       };
100548     }
100549   }
100550
100551   jresult = result;
100552   return jresult;
100553 }
100554
100555
100556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100557   float jresult ;
100558   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100559   float arg2 ;
100560   float arg3 ;
100561   float arg4 ;
100562   float result;
100563
100564   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100565   arg2 = (float)jarg2;
100566   arg3 = (float)jarg3;
100567   arg4 = (float)jarg4;
100568   {
100569     try {
100570       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100571     } catch (std::out_of_range& e) {
100572       {
100573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100574       };
100575     } catch (std::exception& e) {
100576       {
100577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100578       };
100579     } catch (Dali::DaliException e) {
100580       {
100581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100582       };
100583     } catch (...) {
100584       {
100585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100586       };
100587     }
100588   }
100589
100590   jresult = result;
100591   return jresult;
100592 }
100593
100594
100595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100596   float jresult ;
100597   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100598   float arg2 ;
100599   float arg3 ;
100600   float result;
100601
100602   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100603   arg2 = (float)jarg2;
100604   arg3 = (float)jarg3;
100605   {
100606     try {
100607       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
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_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100633   float jresult ;
100634   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100635   float arg2 ;
100636   float result;
100637
100638   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100639   arg2 = (float)jarg2;
100640   {
100641     try {
100642       result = (float)(*arg1)->SnapAndClamp(arg2);
100643     } catch (std::out_of_range& e) {
100644       {
100645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100646       };
100647     } catch (std::exception& e) {
100648       {
100649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100650       };
100651     } catch (Dali::DaliException e) {
100652       {
100653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100654       };
100655     } catch (...) {
100656       {
100657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100658       };
100659     }
100660   }
100661
100662   jresult = result;
100663   return jresult;
100664 }
100665
100666
100667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100668   float jresult ;
100669   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100670   float arg2 ;
100671   float arg3 ;
100672   float arg4 ;
100673   float arg5 ;
100674   Dali::Toolkit::ClampState *arg6 = 0 ;
100675   float result;
100676
100677   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100678   arg2 = (float)jarg2;
100679   arg3 = (float)jarg3;
100680   arg4 = (float)jarg4;
100681   arg5 = (float)jarg5;
100682   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100683   if (!arg6) {
100684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100685     return 0;
100686   }
100687   {
100688     try {
100689       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100690     } catch (std::out_of_range& e) {
100691       {
100692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100693       };
100694     } catch (std::exception& e) {
100695       {
100696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100697       };
100698     } catch (Dali::DaliException e) {
100699       {
100700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100701       };
100702     } catch (...) {
100703       {
100704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100705       };
100706     }
100707   }
100708
100709   jresult = result;
100710   return jresult;
100711 }
100712
100713
100714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100715   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100716
100717   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100718   {
100719     try {
100720       (*arg1)->Reference();
100721     } catch (std::out_of_range& e) {
100722       {
100723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100724       };
100725     } catch (std::exception& e) {
100726       {
100727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100728       };
100729     } catch (Dali::DaliException e) {
100730       {
100731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100732       };
100733     } catch (...) {
100734       {
100735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100736       };
100737     }
100738   }
100739
100740 }
100741
100742
100743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100744   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100745
100746   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100747   {
100748     try {
100749       (*arg1)->Unreference();
100750     } catch (std::out_of_range& e) {
100751       {
100752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100753       };
100754     } catch (std::exception& e) {
100755       {
100756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100757       };
100758     } catch (Dali::DaliException e) {
100759       {
100760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100761       };
100762     } catch (...) {
100763       {
100764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100765       };
100766     }
100767   }
100768
100769 }
100770
100771
100772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100773   int jresult ;
100774   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100775   int result;
100776
100777   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100778   {
100779     try {
100780       result = (int)(*arg1)->ReferenceCount();
100781     } catch (std::out_of_range& e) {
100782       {
100783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100784       };
100785     } catch (std::exception& e) {
100786       {
100787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100788       };
100789     } catch (Dali::DaliException e) {
100790       {
100791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100792       };
100793     } catch (...) {
100794       {
100795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100796       };
100797     }
100798   }
100799
100800   jresult = result;
100801   return jresult;
100802 }
100803
100804
100805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100806   unsigned int jresult ;
100807   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100808   bool result;
100809
100810   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100811   {
100812     try {
100813       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100814     } catch (std::out_of_range& e) {
100815       {
100816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100817       };
100818     } catch (std::exception& e) {
100819       {
100820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100821       };
100822     } catch (Dali::DaliException e) {
100823       {
100824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100825       };
100826     } catch (...) {
100827       {
100828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100829       };
100830     }
100831   }
100832
100833   jresult = result;
100834   return jresult;
100835 }
100836
100837
100838 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100839   unsigned long jresult ;
100840   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100841   std::size_t result;
100842
100843   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100844   {
100845     try {
100846       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100847     } catch (std::out_of_range& e) {
100848       {
100849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100850       };
100851     } catch (std::exception& e) {
100852       {
100853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100854       };
100855     } catch (Dali::DaliException e) {
100856       {
100857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100858       };
100859     } catch (...) {
100860       {
100861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100862       };
100863     }
100864   }
100865
100866   jresult = (unsigned long)result;
100867   return jresult;
100868 }
100869
100870
100871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100872   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100873   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100874
100875   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100876   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100877   {
100878     try {
100879       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100880     } catch (std::out_of_range& e) {
100881       {
100882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100883       };
100884     } catch (std::exception& e) {
100885       {
100886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100887       };
100888     } catch (Dali::DaliException e) {
100889       {
100890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100891       };
100892     } catch (...) {
100893       {
100894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100895       };
100896     }
100897   }
100898
100899 }
100900
100901
100902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100903   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100904   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100905
100906   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100907   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100908   {
100909     try {
100910       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100911     } catch (std::out_of_range& e) {
100912       {
100913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100914       };
100915     } catch (std::exception& e) {
100916       {
100917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100918       };
100919     } catch (Dali::DaliException e) {
100920       {
100921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100922       };
100923     } catch (...) {
100924       {
100925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100926       };
100927     }
100928   }
100929
100930 }
100931
100932
100933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100934   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100935   Dali::Toolkit::Control arg2 ;
100936   Dali::Toolkit::Control *argp2 ;
100937
100938   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100939   argp2 = (Dali::Toolkit::Control *)jarg2;
100940   if (!argp2) {
100941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100942     return ;
100943   }
100944   arg2 = *argp2;
100945   {
100946     try {
100947       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100948     } catch (std::out_of_range& e) {
100949       {
100950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100951       };
100952     } catch (std::exception& e) {
100953       {
100954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100955       };
100956     } catch (Dali::DaliException e) {
100957       {
100958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100959       };
100960     } catch (...) {
100961       {
100962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100963       };
100964     }
100965   }
100966
100967 }
100968
100969
100970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100971   void * jresult ;
100972   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100973
100974   {
100975     try {
100976       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100977     } catch (std::out_of_range& e) {
100978       {
100979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100980       };
100981     } catch (std::exception& e) {
100982       {
100983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100984       };
100985     } catch (Dali::DaliException e) {
100986       {
100987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100988       };
100989     } catch (...) {
100990       {
100991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100992       };
100993     }
100994   }
100995
100996   jresult = (void *)result;
100997   return jresult;
100998 }
100999
101000
101001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
101002   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101003
101004   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101005   {
101006     try {
101007       delete arg1;
101008     } catch (std::out_of_range& e) {
101009       {
101010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101011       };
101012     } catch (std::exception& e) {
101013       {
101014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101015       };
101016     } catch (Dali::DaliException e) {
101017       {
101018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101019       };
101020     } catch (...) {
101021       {
101022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101023       };
101024     }
101025   }
101026
101027 }
101028
101029 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
101030   Dali::RefObject *result = NULL;
101031
101032   if (arg1)
101033   {
101034     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
101035   }
101036   return result;
101037 }
101038
101039 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
101040     return (Dali::RefObject *)jarg1;
101041 }
101042
101043 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
101044     return (Dali::SignalObserver *)jarg1;
101045 }
101046
101047 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
101048     return (Dali::ConnectionTrackerInterface *)jarg1;
101049 }
101050
101051 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
101052     return (Dali::BaseHandle *)jarg1;
101053 }
101054
101055 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
101056     return (Dali::BaseHandle *)jarg1;
101057 }
101058
101059 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
101060     return (Dali::BaseHandle *)jarg1;
101061 }
101062
101063 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101064     return (Dali::BaseHandle *)jarg1;
101065 }
101066
101067 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101068     return (Dali::BaseHandle *)jarg1;
101069 }
101070
101071 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101072     return (Dali::BaseHandle *)jarg1;
101073 }
101074
101075 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101076     return (Dali::BaseHandle *)jarg1;
101077 }
101078
101079 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101080     return (Dali::BaseHandle *)jarg1;
101081 }
101082
101083 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101084     return (Dali::BaseHandle *)jarg1;
101085 }
101086
101087 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101088     return (Dali::BaseHandle *)jarg1;
101089 }
101090
101091 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101092     return (Dali::BaseHandle *)jarg1;
101093 }
101094
101095 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101096     return (Dali::BaseHandle *)jarg1;
101097 }
101098
101099 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101100     return (Dali::BaseHandle *)jarg1;
101101 }
101102
101103 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101104     return (Dali::Handle *)jarg1;
101105 }
101106
101107 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101108     return (Dali::Handle *)jarg1;
101109 }
101110
101111 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101112     return (Dali::BaseHandle *)jarg1;
101113 }
101114
101115 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101116     return (Dali::BaseHandle *)jarg1;
101117 }
101118
101119 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101120     return (Dali::Handle *)jarg1;
101121 }
101122
101123 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101124     return (Dali::BaseHandle *)jarg1;
101125 }
101126
101127 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101128     return (Dali::Handle *)jarg1;
101129 }
101130
101131 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101132     return (Dali::GestureDetector *)jarg1;
101133 }
101134
101135 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101136     return (Dali::Gesture *)jarg1;
101137 }
101138
101139 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101140     return (Dali::Handle *)jarg1;
101141 }
101142
101143 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101144     return (Dali::Actor *)jarg1;
101145 }
101146
101147 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101148     return (Dali::BaseHandle *)jarg1;
101149 }
101150
101151 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101152     return (Dali::RefObject *)jarg1;
101153 }
101154
101155 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101156     return (Dali::Actor *)jarg1;
101157 }
101158
101159 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101160     return (Dali::GestureDetector *)jarg1;
101161 }
101162
101163 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101164     return (Dali::Gesture *)jarg1;
101165 }
101166
101167 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101168     return (Dali::GestureDetector *)jarg1;
101169 }
101170
101171 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101172     return (Dali::Gesture *)jarg1;
101173 }
101174
101175 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101176     return (Dali::GestureDetector *)jarg1;
101177 }
101178
101179 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101180     return (Dali::Gesture *)jarg1;
101181 }
101182
101183 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101184     return (Dali::BaseHandle *)jarg1;
101185 }
101186
101187 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101188     return (Dali::Handle *)jarg1;
101189 }
101190
101191 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101192     return (Dali::Handle *)jarg1;
101193 }
101194
101195 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101196     return (Dali::Handle *)jarg1;
101197 }
101198
101199 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101200     return (Dali::Image *)jarg1;
101201 }
101202
101203 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101204     return (Dali::Image *)jarg1;
101205 }
101206
101207 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101208     return (Dali::Image *)jarg1;
101209 }
101210
101211 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101212     return (Dali::RefObject *)jarg1;
101213 }
101214
101215 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101216     return (Dali::Image *)jarg1;
101217 }
101218
101219 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101220     return (Dali::Image *)jarg1;
101221 }
101222
101223 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101224     return (Dali::ResourceImage *)jarg1;
101225 }
101226
101227 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101228     return (Dali::Actor *)jarg1;
101229 }
101230
101231 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101232     return (Dali::BaseHandle *)jarg1;
101233 }
101234
101235 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101236     return (Dali::BaseHandle *)jarg1;
101237 }
101238
101239
101240 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101241     return (Dali::BaseHandle *)jarg1;
101242 }
101243
101244 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101245     return (Dali::BaseHandle *)jarg1;
101246 }
101247
101248 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101249     return (Dali::CustomActorImpl *)jarg1;
101250 }
101251
101252 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101253     return (Dali::CustomActor *)jarg1;
101254 }
101255
101256 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101257     return (Dali::BaseHandle *)jarg1;
101258 }
101259
101260 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101261     return (Dali::Toolkit::Control *)jarg1;
101262 }
101263
101264 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101265     return (Dali::Toolkit::Control *)jarg1;
101266 }
101267
101268 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101269     return (Dali::Toolkit::Button *)jarg1;
101270 }
101271
101272 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101273     return (Dali::Toolkit::Button *)jarg1;
101274 }
101275
101276 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101277     return (Dali::Toolkit::Button *)jarg1;
101278 }
101279
101280 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101281     return (Dali::Toolkit::Control *)jarg1;
101282 }
101283
101284 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101285     return (Dali::Toolkit::Control *)jarg1;
101286 }
101287
101288 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101289     return (Dali::Toolkit::Control *)jarg1;
101290 }
101291
101292 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101293     return (Dali::Toolkit::Control *)jarg1;
101294 }
101295
101296 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101297     return (Dali::Toolkit::Control *)jarg1;
101298 }
101299
101300 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101301     return (Dali::RefObject *)jarg1;
101302 }
101303
101304 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101305     return (Dali::Toolkit::Scrollable *)jarg1;
101306 }
101307
101308 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101309     return (Dali::BaseHandle *)jarg1;
101310 }
101311
101312 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101313     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101314 }
101315
101316 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101317     return (Dali::RefObject *)jarg1;
101318 }
101319
101320 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101321     return (Dali::Toolkit::Ruler *)jarg1;
101322 }
101323
101324 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101325     return (Dali::Toolkit::Ruler *)jarg1;
101326 }
101327
101328 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101329     return (Dali::Toolkit::Scrollable *)jarg1;
101330 }
101331
101332 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101333     return (Dali::Toolkit::Control *)jarg1;
101334 }
101335
101336
101337 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101338     return (Dali::Toolkit::Control *)jarg1;
101339 }
101340
101341 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101342     return (Dali::BaseHandle *)jarg1;
101343 }
101344
101345 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101346     return (Dali::BaseHandle *)jarg1;
101347 }
101348
101349 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101350     return (Dali::Toolkit::Control *)jarg1;
101351 }
101352
101353 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101354     return (Dali::Toolkit::Control *)jarg1;
101355 }
101356
101357 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101358     return (Dali::Toolkit::Control *)jarg1;
101359 }
101360
101361 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101362     return (Dali::Toolkit::Control *)jarg1;
101363 }
101364
101365 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101366     return (Dali::Toolkit::Control *)jarg1;
101367 }
101368
101369 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101370     return (Dali::Toolkit::Control *)jarg1;
101371 }
101372
101373 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101374     return (Dali::Toolkit::PageTurnView *)jarg1;
101375 }
101376
101377 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101378     return (Dali::Toolkit::PageTurnView *)jarg1;
101379 }
101380
101381 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101382     return (Dali::Toolkit::Button *)jarg1;
101383 }
101384
101385 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101386     return (Dali::BaseHandle *)jarg1;
101387 }
101388
101389 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101390     return (Dali::BaseHandle *)jarg1;
101391 }
101392
101393 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101394     return (Dali::BaseHandle *)jarg1;
101395 }
101396
101397 /*
101398  * Widget binding
101399  */
101400 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101401     return (Dali::BaseHandle *)jarg1;
101402 }
101403
101404 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101405     return (Dali::BaseObject *)jarg1;
101406 }
101407
101408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101409   void * jresult ;
101410   Dali::Widget result;
101411
101412   {
101413     try {
101414       result = Dali::Widget::New();
101415     } catch (std::out_of_range& e) {
101416       {
101417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101418       };
101419     } catch (std::exception& e) {
101420       {
101421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101422       };
101423     } catch (...) {
101424       {
101425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101426       };
101427     }
101428   }
101429   jresult = new Dali::Widget((const Dali::Widget &)result);
101430   return jresult;
101431 }
101432
101433
101434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101435   void * jresult ;
101436   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101437   Dali::Widget result;
101438
101439   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101440
101441   if (!arg1) {
101442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101443     return 0;
101444   }
101445   {
101446     try {
101447       jresult = new Dali::Widget(arg1);
101448     } catch (std::out_of_range& e) {
101449       {
101450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101451       };
101452     } catch (std::exception& e) {
101453       {
101454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101455       };
101456     } catch (...) {
101457       {
101458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101459       };
101460     }
101461   }
101462   return jresult;
101463 }
101464
101465
101466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101467   void * jresult ;
101468   Dali::Widget *result = 0 ;
101469
101470   {
101471     try {
101472       result = (Dali::Widget *)new Dali::Widget();
101473     } catch (std::out_of_range& e) {
101474       {
101475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101476       };
101477     } catch (std::exception& e) {
101478       {
101479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101480       };
101481     } catch (...) {
101482       {
101483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101484       };
101485     }
101486   }
101487   jresult = (void *)result;
101488   return jresult;
101489 }
101490
101491
101492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101493   void * jresult ;
101494   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101495   Dali::Widget *arg2 = 0 ;
101496   Dali::Widget *result = 0 ;
101497
101498   arg1 = (Dali::Widget *)jarg1;
101499   arg2 = (Dali::Widget *)jarg2;
101500   if (!arg2) {
101501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101502     return 0;
101503   }
101504   {
101505     try {
101506       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101507     } catch (std::out_of_range& e) {
101508       {
101509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101510       };
101511     } catch (std::exception& e) {
101512       {
101513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101514       };
101515     } catch (...) {
101516       {
101517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101518       };
101519     }
101520   }
101521   jresult = (void *)result;
101522   return jresult;
101523 }
101524
101525
101526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101527   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101528
101529   arg1 = (Dali::Widget *)jarg1;
101530   {
101531     try {
101532       delete arg1;
101533     } catch (std::out_of_range& e) {
101534       {
101535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101536       };
101537     } catch (std::exception& e) {
101538       {
101539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101540       };
101541     } catch (...) {
101542       {
101543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101544       };
101545     }
101546   }
101547 }
101548
101549
101550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101551   void * jresult ;
101552   SwigDirector_WidgetImpl* result;
101553   {
101554     try {
101555       result = new SwigDirector_WidgetImpl();
101556     } catch (std::out_of_range& e) {
101557       {
101558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101559       };
101560     } catch (std::exception& e) {
101561       {
101562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101563       };
101564     } catch (...) {
101565       {
101566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101567       };
101568     }
101569   }
101570   jresult = result;
101571   return jresult;
101572 }
101573
101574
101575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101576   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101577   std::string *arg2 = 0 ;
101578   Dali::Window arg3 ;
101579   Dali::Window *argp3 ;
101580
101581   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101582   if (!jarg2) {
101583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101584     return ;
101585   }
101586   std::string arg2_str(jarg2);
101587   arg2 = &arg2_str;
101588   argp3 = (Dali::Window *)jarg3;
101589   if (!argp3) {
101590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101591     return ;
101592   }
101593   arg3 = *argp3;
101594   {
101595     try {
101596       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101597     } catch (std::out_of_range& e) {
101598       {
101599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101600       };
101601     } catch (std::exception& e) {
101602       {
101603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101604       };
101605     } catch (...) {
101606       {
101607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101608       };
101609     }
101610   }
101611 }
101612
101613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101614   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101615   std::string *arg2 = 0 ;
101616   Dali::Window arg3 ;
101617   Dali::Window *argp3 ;
101618
101619   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101620   if (!jarg2) {
101621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101622     return ;
101623   }
101624   std::string arg2_str(jarg2);
101625   arg2 = &arg2_str;
101626   argp3 = (Dali::Window *)jarg3;
101627   if (!argp3) {
101628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101629     return ;
101630   }
101631   arg3 = *argp3;
101632   {
101633     try {
101634       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101635     } catch (std::out_of_range& e) {
101636       {
101637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101638       };
101639     } catch (std::exception& e) {
101640       {
101641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101642       };
101643     } catch (...) {
101644       {
101645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101646       };
101647     }
101648   }
101649 }
101650
101651
101652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101653   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101654   std::string *arg2 = 0 ;
101655   Dali::Widget::Termination arg3 ;
101656
101657   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101658   if (!jarg2) {
101659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101660     return ;
101661   }
101662   std::string arg2_str(jarg2);
101663   arg2 = &arg2_str;
101664   arg3 = (Dali::Widget::Termination)jarg3;
101665   {
101666     try {
101667       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101668     } catch (std::out_of_range& e) {
101669       {
101670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101671       };
101672     } catch (std::exception& e) {
101673       {
101674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101675       };
101676     } catch (...) {
101677       {
101678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101679       };
101680     }
101681   }
101682 }
101683
101684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101685   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101686   std::string *arg2 = 0 ;
101687   Dali::Widget::Termination arg3 ;
101688
101689   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101690   if (!jarg2) {
101691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101692     return ;
101693   }
101694   std::string arg2_str(jarg2);
101695   arg2 = &arg2_str;
101696   arg3 = (Dali::Widget::Termination)jarg3;
101697   {
101698     try {
101699       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101700     } catch (std::out_of_range& e) {
101701       {
101702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101703       };
101704     } catch (std::exception& e) {
101705       {
101706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101707       };
101708     } catch (...) {
101709       {
101710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101711       };
101712     }
101713   }
101714 }
101715
101716
101717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101718   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101719
101720   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101721   {
101722     try {
101723       (arg1)->OnPause();
101724     } catch (std::out_of_range& e) {
101725       {
101726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101727       };
101728     } catch (std::exception& e) {
101729       {
101730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101731       };
101732     } catch (...) {
101733       {
101734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101735       };
101736     }
101737   }
101738 }
101739
101740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101741   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101742
101743   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101744   {
101745     try {
101746       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101747     } catch (std::out_of_range& e) {
101748       {
101749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101750       };
101751     } catch (std::exception& e) {
101752       {
101753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101754       };
101755     } catch (...) {
101756       {
101757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101758       };
101759     }
101760   }
101761 }
101762
101763
101764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101765   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101766
101767   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101768   {
101769     try {
101770       (arg1)->OnResume();
101771     } catch (std::out_of_range& e) {
101772       {
101773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101774       };
101775     } catch (std::exception& e) {
101776       {
101777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101778       };
101779     } catch (...) {
101780       {
101781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101782       };
101783     }
101784   }
101785 }
101786
101787
101788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101789   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101790
101791   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101792   {
101793     try {
101794       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101795     } catch (std::out_of_range& e) {
101796       {
101797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101798       };
101799     } catch (std::exception& e) {
101800       {
101801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101802       };
101803     } catch (...) {
101804       {
101805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101806       };
101807     }
101808   }
101809 }
101810
101811
101812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101813   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101814   Dali::Window arg2 ;
101815   Dali::Window *argp2 ;
101816
101817   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101818   argp2 = (Dali::Window *)jarg2;
101819   if (!argp2) {
101820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101821     return ;
101822   }
101823   arg2 = *argp2;
101824   {
101825     try {
101826       (arg1)->OnResize(arg2);
101827     } catch (std::out_of_range& e) {
101828       {
101829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101830       };
101831     } catch (std::exception& e) {
101832       {
101833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101834       };
101835     } catch (...) {
101836       {
101837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101838       };
101839     }
101840   }
101841 }
101842
101843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101844   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101845   Dali::Window arg2 ;
101846   Dali::Window *argp2 ;
101847
101848   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101849   argp2 = (Dali::Window *)jarg2;
101850   if (!argp2) {
101851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101852     return ;
101853   }
101854   arg2 = *argp2;
101855   {
101856     try {
101857       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101858     } catch (std::out_of_range& e) {
101859       {
101860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101861       };
101862     } catch (std::exception& e) {
101863       {
101864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101865       };
101866     } catch (...) {
101867       {
101868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101869       };
101870     }
101871   }
101872 }
101873
101874
101875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101876   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101877   std::string *arg2 = 0 ;
101878   int arg3 ;
101879
101880   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101881   if (!jarg2) {
101882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101883     return ;
101884   }
101885   std::string arg2_str(jarg2);
101886   arg2 = &arg2_str;
101887   arg3 = (int)jarg3;
101888   {
101889     try {
101890       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101891     } catch (std::out_of_range& e) {
101892       {
101893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101894       };
101895     } catch (std::exception& e) {
101896       {
101897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101898       };
101899     } catch (...) {
101900       {
101901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101902       };
101903     }
101904   }
101905 }
101906
101907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101908   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101909   std::string *arg2 = 0 ;
101910   int arg3 ;
101911
101912   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101913   if (!jarg2) {
101914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101915     return ;
101916   }
101917   std::string arg2_str(jarg2);
101918   arg2 = &arg2_str;
101919   arg3 = (int)jarg3;
101920   {
101921     try {
101922       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101923     } catch (std::out_of_range& e) {
101924       {
101925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101926       };
101927     } catch (std::exception& e) {
101928       {
101929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101930       };
101931     } catch (...) {
101932       {
101933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101934       };
101935     }
101936   }
101937 }
101938
101939
101940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101941   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101942   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101943   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101944
101945   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101946   arg2 = (Dali::SlotObserver *)jarg2;
101947   arg3 = (Dali::CallbackBase *)jarg3;
101948   {
101949     try {
101950       (arg1)->SignalConnected(arg2,arg3);
101951     } catch (std::out_of_range& e) {
101952       {
101953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101954       };
101955     } catch (std::exception& e) {
101956       {
101957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101958       };
101959     } catch (...) {
101960       {
101961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101962       };
101963     }
101964   }
101965 }
101966
101967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101968   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101969   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101970   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101971
101972   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101973   arg2 = (Dali::SlotObserver *)jarg2;
101974   arg3 = (Dali::CallbackBase *)jarg3;
101975   {
101976     try {
101977       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101978     } catch (std::out_of_range& e) {
101979       {
101980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101981       };
101982     } catch (std::exception& e) {
101983       {
101984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101985       };
101986     } catch (...) {
101987       {
101988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101989       };
101990     }
101991   }
101992 }
101993
101994
101995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101996   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101997   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101998   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101999
102000   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102001   arg2 = (Dali::SlotObserver *)jarg2;
102002   arg3 = (Dali::CallbackBase *)jarg3;
102003   {
102004     try {
102005       (arg1)->SignalDisconnected(arg2,arg3);
102006     } catch (std::out_of_range& e) {
102007       {
102008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102009       };
102010     } catch (std::exception& e) {
102011       {
102012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102013       };
102014     } catch (...) {
102015       {
102016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102017       };
102018     }
102019   }
102020 }
102021
102022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102023   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102024   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102025   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102026
102027   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102028   arg2 = (Dali::SlotObserver *)jarg2;
102029   arg3 = (Dali::CallbackBase *)jarg3;
102030   {
102031     try {
102032       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
102033     } catch (std::out_of_range& e) {
102034       {
102035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102036       };
102037     } catch (std::exception& e) {
102038       {
102039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102040       };
102041     } catch (...) {
102042       {
102043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102044       };
102045     }
102046   }
102047 }
102048
102049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
102050   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102051   std::string *arg2 = 0 ;
102052
102053   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102054   if (!jarg2) {
102055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102056     return ;
102057   }
102058   std::string arg2_str(jarg2);
102059   arg2 = &arg2_str;
102060   {
102061     try {
102062       (arg1)->SetContentInfo((std::string const &)*arg2);
102063     } catch (std::out_of_range& e) {
102064       {
102065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102066       };
102067     } catch (std::exception& e) {
102068       {
102069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102070       };
102071     } catch (...) {
102072       {
102073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102074       };
102075     }
102076   }
102077 }
102078
102079
102080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102081   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102082   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102083
102084   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102085   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102086   {
102087     try {
102088       (arg1)->SetImpl(arg2);
102089     } catch (std::out_of_range& e) {
102090       {
102091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102092       };
102093     } catch (std::exception& e) {
102094       {
102095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102096       };
102097     } catch (...) {
102098       {
102099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102100       };
102101     }
102102   }
102103 }
102104
102105 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) {
102106
102107   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102108   if (director) {
102109     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102110   }
102111 }
102112
102113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102114   void * jresult ;
102115   Dali::Widget *arg1 = 0 ;
102116   SwigDirector_WidgetImpl *result = 0 ;
102117
102118   arg1 = (Dali::Widget *)jarg1;
102119   if (!arg1) {
102120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102121     return 0;
102122   }
102123   {
102124     try {
102125       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
102126     } catch (std::out_of_range& e) {
102127       {
102128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102129       };
102130     } catch (std::exception& e) {
102131       {
102132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102133       };
102134     } catch (...) {
102135       {
102136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102137       };
102138     }
102139   }
102140
102141   jresult = (void *)result;
102142   return jresult;
102143 }
102144
102145
102146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102147   void * jresult ;
102148   int *arg1 = (int *) 0 ;
102149   char ***arg2 ;
102150   std::string *arg3 = 0 ;
102151   Dali::WidgetApplication result;
102152   {
102153     int index = 0;
102154     int length = 0;
102155     char *retPtr;
102156     char *nextPtr;
102157     argWidgetC = jarg1;
102158     argWidgetV = new char*[jarg1 + 1];
102159
102160     retPtr = strtok_r( jarg2, " ", &nextPtr);
102161     if( retPtr )
102162     {
102163       length = strlen(retPtr);
102164     }
102165     argWidgetV[index] = new char[length + 1];
102166     if( retPtr )
102167     {
102168       strncpy(argWidgetV[index], retPtr, length);
102169     }
102170     argWidgetV[index][length] = '\0';
102171     index++;
102172
102173     while (index < jarg1)
102174     {
102175       length = 0;
102176       retPtr = strtok_r(NULL, " ", &nextPtr);
102177       if( retPtr )
102178       {
102179         length = strlen(retPtr);
102180       }
102181       argWidgetV[index] = new char[length + 1];
102182       if( retPtr )
102183       {
102184         strncpy(argWidgetV[index], retPtr, length);
102185       }
102186       argWidgetV[index][length] = '\0';
102187       index++;
102188     }
102189
102190     argWidgetV[jarg1] = NULL;
102191     argWidgetC = jarg1;
102192
102193     arg1 = &argWidgetC;
102194     arg2 = &argWidgetV;
102195   }
102196
102197   if (!jarg3) {
102198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102199     return 0;
102200   }
102201   std::string arg3_str(jarg3);
102202   arg3 = &arg3_str;
102203   {
102204     try {
102205       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102206     } catch (std::out_of_range& e) {
102207       {
102208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102209       };
102210     } catch (std::exception& e) {
102211       {
102212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102213       };
102214     } catch (...) {
102215       {
102216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102217       };
102218     }
102219   }
102220   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102221
102222   return jresult;
102223 }
102224
102225
102226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102227   void * jresult ;
102228   Dali::WidgetApplication *result = 0 ;
102229
102230   {
102231     try {
102232       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102233     } catch (std::out_of_range& e) {
102234       {
102235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102236       };
102237     } catch (std::exception& e) {
102238       {
102239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102240       };
102241     } catch (...) {
102242       {
102243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102244       };
102245     }
102246   }
102247   jresult = (void *)result;
102248   return jresult;
102249 }
102250
102251
102252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102253   void * jresult ;
102254   Dali::WidgetApplication *arg1 = 0 ;
102255   Dali::WidgetApplication *result = 0 ;
102256
102257   arg1 = (Dali::WidgetApplication *)jarg1;
102258   if (!arg1) {
102259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102260     return 0;
102261   }
102262   {
102263     try {
102264       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
102265     } catch (std::out_of_range& e) {
102266       {
102267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102268       };
102269     } catch (std::exception& e) {
102270       {
102271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102272       };
102273     } catch (...) {
102274       {
102275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102276       };
102277     }
102278   }
102279   jresult = (void *)result;
102280   return jresult;
102281 }
102282
102283
102284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102285   void * jresult ;
102286   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102287   Dali::WidgetApplication *arg2 = 0 ;
102288   Dali::WidgetApplication *result = 0 ;
102289
102290   arg1 = (Dali::WidgetApplication *)jarg1;
102291   arg2 = (Dali::WidgetApplication *)jarg2;
102292   if (!arg2) {
102293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102294     return 0;
102295   }
102296   {
102297     try {
102298       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102299     } catch (std::out_of_range& e) {
102300       {
102301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102302       };
102303     } catch (std::exception& e) {
102304       {
102305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102306       };
102307     } catch (...) {
102308       {
102309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102310       };
102311     }
102312   }
102313   jresult = (void *)result;
102314   return jresult;
102315 }
102316
102317
102318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102319   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102320
102321   arg1 = (Dali::WidgetApplication *)jarg1;
102322   {
102323     try {
102324       delete arg1;
102325       if( argWidgetV )
102326       {
102327         // free string data
102328         for( int i=0; i < argWidgetC+1; i++)
102329         {
102330           delete [] argWidgetV[i];
102331         }
102332         delete [] argWidgetV;
102333       }
102334     } catch (std::out_of_range& e) {
102335       {
102336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102337       };
102338     } catch (std::exception& e) {
102339       {
102340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102341       };
102342     } catch (...) {
102343       {
102344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102345       };
102346     }
102347   }
102348 }
102349
102350
102351 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102352 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102353
102354 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102355 {
102356   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102357   return *widget;
102358 }
102359
102360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102361   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102362   std::string *arg2 = 0 ;
102363
102364   arg1 = (Dali::WidgetApplication *)jarg1;
102365   if (!jarg2) {
102366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102367     return ;
102368   }
102369   std::string arg2_str(*jarg2);
102370   arg2 = &arg2_str;
102371
102372   if(!_CSharpCreateWidgetFunction)
102373   {
102374     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102375   }
102376
102377   {
102378     try {
102379       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102380     } catch (std::out_of_range& e) {
102381       {
102382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102383       };
102384     } catch (std::exception& e) {
102385       {
102386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102387       };
102388     } catch (...) {
102389       {
102390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102391       };
102392     }
102393   }
102394
102395   //Typemap argout in c++ file.
102396   //This will convert c++ string to c# string
102397   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102398 }
102399
102400
102401 //for PixelBuffer and ImageLoading
102402
102403 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102404     return (Dali::BaseHandle *)jarg1;
102405 }
102406
102407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102408   void * jresult ;
102409   unsigned int arg1 ;
102410   unsigned int arg2 ;
102411   Dali::Pixel::Format arg3 ;
102412   Dali::Devel::PixelBuffer result;
102413
102414   arg1 = (unsigned int)jarg1;
102415   arg2 = (unsigned int)jarg2;
102416   arg3 = (Dali::Pixel::Format)jarg3;
102417   {
102418     try {
102419       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102420     } catch (std::out_of_range& e) {
102421       {
102422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102423       };
102424     } catch (std::exception& e) {
102425       {
102426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102427       };
102428     } catch (...) {
102429       {
102430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102431       };
102432     }
102433   }
102434   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102435   return jresult;
102436 }
102437
102438
102439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102440   void * jresult ;
102441   Dali::Devel::PixelBuffer *result = 0 ;
102442
102443   {
102444     try {
102445       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102446     } catch (std::out_of_range& e) {
102447       {
102448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102449       };
102450     } catch (std::exception& e) {
102451       {
102452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102453       };
102454     } catch (...) {
102455       {
102456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102457       };
102458     }
102459   }
102460   jresult = (void *)result;
102461   return jresult;
102462 }
102463
102464
102465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102466   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102467
102468   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102469   {
102470     try {
102471       delete arg1;
102472     } catch (std::out_of_range& e) {
102473       {
102474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102475       };
102476     } catch (std::exception& e) {
102477       {
102478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102479       };
102480     } catch (...) {
102481       {
102482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102483       };
102484     }
102485   }
102486 }
102487
102488
102489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102490   void * jresult ;
102491   Dali::Devel::PixelBuffer *arg1 = 0 ;
102492   Dali::Devel::PixelBuffer *result = 0 ;
102493
102494   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102495   if (!arg1) {
102496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102497     return 0;
102498   }
102499   {
102500     try {
102501       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102502     } catch (std::out_of_range& e) {
102503       {
102504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102505       };
102506     } catch (std::exception& e) {
102507       {
102508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102509       };
102510     } catch (...) {
102511       {
102512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102513       };
102514     }
102515   }
102516   jresult = (void *)result;
102517   return jresult;
102518 }
102519
102520
102521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102522   void * jresult ;
102523   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102524   Dali::Devel::PixelBuffer *arg2 = 0 ;
102525   Dali::Devel::PixelBuffer *result = 0 ;
102526
102527   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102528   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102529   if (!arg2) {
102530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102531     return 0;
102532   }
102533   {
102534     try {
102535       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102536     } catch (std::out_of_range& e) {
102537       {
102538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102539       };
102540     } catch (std::exception& e) {
102541       {
102542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102543       };
102544     } catch (...) {
102545       {
102546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102547       };
102548     }
102549   }
102550   jresult = (void *)result;
102551   return jresult;
102552 }
102553
102554
102555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102556   void * jresult ;
102557   Dali::Devel::PixelBuffer *arg1 = 0 ;
102558   Dali::PixelData result;
102559
102560   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102561   if (!arg1) {
102562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102563     return 0;
102564   }
102565   {
102566     try {
102567       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102568     } catch (std::out_of_range& e) {
102569       {
102570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102571       };
102572     } catch (std::exception& e) {
102573       {
102574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102575       };
102576     } catch (...) {
102577       {
102578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102579       };
102580     }
102581   }
102582   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102583   return jresult;
102584 }
102585
102586
102587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102588   void * jresult ;
102589   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102590   Dali::PixelData result;
102591
102592   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102593   {
102594     try {
102595       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102596     } catch (std::out_of_range& e) {
102597       {
102598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102599       };
102600     } catch (std::exception& e) {
102601       {
102602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102603       };
102604     } catch (...) {
102605       {
102606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102607       };
102608     }
102609   }
102610   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102611   return jresult;
102612 }
102613
102614
102615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102616   void * jresult ;
102617   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102618   unsigned char *result = 0 ;
102619
102620   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102621   {
102622     try {
102623       result = (unsigned char *)(arg1)->GetBuffer();
102624     } catch (std::out_of_range& e) {
102625       {
102626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102627       };
102628     } catch (std::exception& e) {
102629       {
102630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102631       };
102632     } catch (...) {
102633       {
102634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102635       };
102636     }
102637   }
102638   jresult = (void *)result;
102639   return jresult;
102640 }
102641
102642
102643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102644   unsigned int jresult ;
102645   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102646   unsigned int result;
102647
102648   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102649   {
102650     try {
102651       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102652     } catch (std::out_of_range& e) {
102653       {
102654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102655       };
102656     } catch (std::exception& e) {
102657       {
102658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102659       };
102660     } catch (...) {
102661       {
102662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102663       };
102664     }
102665   }
102666   jresult = result;
102667   return jresult;
102668 }
102669
102670
102671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102672   unsigned int jresult ;
102673   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102674   unsigned int result;
102675
102676   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102677   {
102678     try {
102679       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102680     } catch (std::out_of_range& e) {
102681       {
102682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102683       };
102684     } catch (std::exception& e) {
102685       {
102686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102687       };
102688     } catch (...) {
102689       {
102690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102691       };
102692     }
102693   }
102694   jresult = result;
102695   return jresult;
102696 }
102697
102698
102699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102700   int jresult ;
102701   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102702   Dali::Pixel::Format result;
102703
102704   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102705   {
102706     try {
102707       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102708     } catch (std::out_of_range& e) {
102709       {
102710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102711       };
102712     } catch (std::exception& e) {
102713       {
102714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102715       };
102716     } catch (...) {
102717       {
102718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102719       };
102720     }
102721   }
102722   jresult = (int)result;
102723   return jresult;
102724 }
102725
102726
102727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102728   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102729   Dali::Devel::PixelBuffer arg2 ;
102730   float arg3 ;
102731   bool arg4 ;
102732   Dali::Devel::PixelBuffer *argp2 ;
102733
102734   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102735   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102736   if (!argp2) {
102737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102738     return ;
102739   }
102740   arg2 = *argp2;
102741   arg3 = (float)jarg3;
102742   arg4 = jarg4 ? true : false;
102743   {
102744     try {
102745       (arg1)->ApplyMask(arg2,arg3,arg4);
102746     } catch (std::out_of_range& e) {
102747       {
102748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102749       };
102750     } catch (std::exception& e) {
102751       {
102752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102753       };
102754     } catch (...) {
102755       {
102756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102757       };
102758     }
102759   }
102760 }
102761
102762
102763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102764   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102765   Dali::Devel::PixelBuffer arg2 ;
102766   float arg3 ;
102767   Dali::Devel::PixelBuffer *argp2 ;
102768
102769   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102770   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102771   if (!argp2) {
102772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102773     return ;
102774   }
102775   arg2 = *argp2;
102776   arg3 = (float)jarg3;
102777   {
102778     try {
102779       (arg1)->ApplyMask(arg2,arg3);
102780     } catch (std::out_of_range& e) {
102781       {
102782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102783       };
102784     } catch (std::exception& e) {
102785       {
102786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102787       };
102788     } catch (...) {
102789       {
102790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102791       };
102792     }
102793   }
102794 }
102795
102796
102797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102798   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102799   Dali::Devel::PixelBuffer arg2 ;
102800   Dali::Devel::PixelBuffer *argp2 ;
102801
102802   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102803   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102804   if (!argp2) {
102805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102806     return ;
102807   }
102808   arg2 = *argp2;
102809   {
102810     try {
102811       (arg1)->ApplyMask(arg2);
102812     } catch (std::out_of_range& e) {
102813       {
102814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102815       };
102816     } catch (std::exception& e) {
102817       {
102818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102819       };
102820     } catch (...) {
102821       {
102822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102823       };
102824     }
102825   }
102826 }
102827
102828
102829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102830   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102831   float arg2 ;
102832
102833   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102834   arg2 = (float)jarg2;
102835   {
102836     try {
102837       (arg1)->ApplyGaussianBlur(arg2);
102838     } catch (std::out_of_range& e) {
102839       {
102840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102841       };
102842     } catch (std::exception& e) {
102843       {
102844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102845       };
102846     } catch (...) {
102847       {
102848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102849       };
102850     }
102851   }
102852 }
102853
102854
102855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102856   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102857   uint16_t arg2 ;
102858   uint16_t arg3 ;
102859   uint16_t arg4 ;
102860   uint16_t arg5 ;
102861
102862   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102863   arg2 = (uint16_t)jarg2;
102864   arg3 = (uint16_t)jarg3;
102865   arg4 = (uint16_t)jarg4;
102866   arg5 = (uint16_t)jarg5;
102867   {
102868     try {
102869       (arg1)->Crop(arg2,arg3,arg4,arg5);
102870     } catch (std::out_of_range& e) {
102871       {
102872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102873       };
102874     } catch (std::exception& e) {
102875       {
102876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102877       };
102878     } catch (...) {
102879       {
102880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102881       };
102882     }
102883   }
102884 }
102885
102886
102887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102888   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102889   uint16_t arg2 ;
102890   uint16_t arg3 ;
102891
102892   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102893   arg2 = (uint16_t)jarg2;
102894   arg3 = (uint16_t)jarg3;
102895   {
102896     try {
102897       (arg1)->Resize(arg2,arg3);
102898     } catch (std::out_of_range& e) {
102899       {
102900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102901       };
102902     } catch (std::exception& e) {
102903       {
102904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102905       };
102906     } catch (...) {
102907       {
102908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102909       };
102910     }
102911   }
102912 }
102913
102914
102915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102916   void * jresult ;
102917   std::string *arg1 = 0 ;
102918   Dali::ImageDimensions arg2 ;
102919   Dali::FittingMode::Type arg3 ;
102920   Dali::SamplingMode::Type arg4 ;
102921   bool arg5 ;
102922   Dali::ImageDimensions *argp2 ;
102923   Dali::Devel::PixelBuffer result;
102924
102925   if (!jarg1) {
102926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102927     return 0;
102928   }
102929   std::string arg1_str(jarg1);
102930   arg1 = &arg1_str;
102931   argp2 = (Dali::ImageDimensions *)jarg2;
102932   if (!argp2) {
102933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102934     return 0;
102935   }
102936   arg2 = *argp2;
102937   arg3 = (Dali::FittingMode::Type)jarg3;
102938   arg4 = (Dali::SamplingMode::Type)jarg4;
102939   arg5 = jarg5 ? true : false;
102940   {
102941     try {
102942       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102943     } catch (std::out_of_range& e) {
102944       {
102945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102946       };
102947     } catch (std::exception& e) {
102948       {
102949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102950       };
102951     } catch (...) {
102952       {
102953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102954       };
102955     }
102956   }
102957   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102958
102959   return jresult;
102960 }
102961
102962
102963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102964   void * jresult ;
102965   std::string *arg1 = 0 ;
102966   Dali::ImageDimensions arg2 ;
102967   Dali::FittingMode::Type arg3 ;
102968   Dali::SamplingMode::Type arg4 ;
102969   Dali::ImageDimensions *argp2 ;
102970   Dali::Devel::PixelBuffer result;
102971
102972   if (!jarg1) {
102973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102974     return 0;
102975   }
102976   std::string arg1_str(jarg1);
102977   arg1 = &arg1_str;
102978   argp2 = (Dali::ImageDimensions *)jarg2;
102979   if (!argp2) {
102980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102981     return 0;
102982   }
102983   arg2 = *argp2;
102984   arg3 = (Dali::FittingMode::Type)jarg3;
102985   arg4 = (Dali::SamplingMode::Type)jarg4;
102986   {
102987     try {
102988       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102989     } catch (std::out_of_range& e) {
102990       {
102991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102992       };
102993     } catch (std::exception& e) {
102994       {
102995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102996       };
102997     } catch (...) {
102998       {
102999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103000       };
103001     }
103002   }
103003   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103004
103005   return jresult;
103006 }
103007
103008
103009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103010   void * jresult ;
103011   std::string *arg1 = 0 ;
103012   Dali::ImageDimensions arg2 ;
103013   Dali::FittingMode::Type arg3 ;
103014   Dali::ImageDimensions *argp2 ;
103015   Dali::Devel::PixelBuffer result;
103016
103017   if (!jarg1) {
103018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103019     return 0;
103020   }
103021   std::string arg1_str(jarg1);
103022   arg1 = &arg1_str;
103023   argp2 = (Dali::ImageDimensions *)jarg2;
103024   if (!argp2) {
103025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103026     return 0;
103027   }
103028   arg2 = *argp2;
103029   arg3 = (Dali::FittingMode::Type)jarg3;
103030   {
103031     try {
103032       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
103033     } catch (std::out_of_range& e) {
103034       {
103035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103036       };
103037     } catch (std::exception& e) {
103038       {
103039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103040       };
103041     } catch (...) {
103042       {
103043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103044       };
103045     }
103046   }
103047   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103048
103049   return jresult;
103050 }
103051
103052
103053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
103054   void * jresult ;
103055   std::string *arg1 = 0 ;
103056   Dali::ImageDimensions arg2 ;
103057   Dali::ImageDimensions *argp2 ;
103058   Dali::Devel::PixelBuffer result;
103059
103060   if (!jarg1) {
103061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103062     return 0;
103063   }
103064   std::string arg1_str(jarg1);
103065   arg1 = &arg1_str;
103066   argp2 = (Dali::ImageDimensions *)jarg2;
103067   if (!argp2) {
103068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103069     return 0;
103070   }
103071   arg2 = *argp2;
103072   {
103073     try {
103074       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103075     } catch (std::out_of_range& e) {
103076       {
103077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103078       };
103079     } catch (std::exception& e) {
103080       {
103081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103082       };
103083     } catch (...) {
103084       {
103085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103086       };
103087     }
103088   }
103089   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103090
103091   return jresult;
103092 }
103093
103094
103095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103096   void * jresult ;
103097   std::string *arg1 = 0 ;
103098   Dali::Devel::PixelBuffer result;
103099
103100   if (!jarg1) {
103101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103102     return 0;
103103   }
103104   std::string arg1_str(jarg1);
103105   arg1 = &arg1_str;
103106   {
103107     try {
103108       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103109     } catch (std::out_of_range& e) {
103110       {
103111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103112       };
103113     } catch (std::exception& e) {
103114       {
103115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103116       };
103117     } catch (...) {
103118       {
103119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103120       };
103121     }
103122   }
103123   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103124
103125   return jresult;
103126 }
103127
103128
103129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103130   void * jresult ;
103131   std::string *arg1 = 0 ;
103132   Dali::ImageDimensions arg2 ;
103133   Dali::FittingMode::Type arg3 ;
103134   Dali::SamplingMode::Type arg4 ;
103135   bool arg5 ;
103136   Dali::ImageDimensions *argp2 ;
103137   Dali::ImageDimensions result;
103138
103139   if (!jarg1) {
103140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103141     return 0;
103142   }
103143   std::string arg1_str(jarg1);
103144   arg1 = &arg1_str;
103145   argp2 = (Dali::ImageDimensions *)jarg2;
103146   if (!argp2) {
103147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103148     return 0;
103149   }
103150   arg2 = *argp2;
103151   arg3 = (Dali::FittingMode::Type)jarg3;
103152   arg4 = (Dali::SamplingMode::Type)jarg4;
103153   arg5 = jarg5 ? true : false;
103154   {
103155     try {
103156       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103157     } catch (std::out_of_range& e) {
103158       {
103159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103160       };
103161     } catch (std::exception& e) {
103162       {
103163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103164       };
103165     } catch (...) {
103166       {
103167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103168       };
103169     }
103170   }
103171   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103172
103173   return jresult;
103174 }
103175
103176
103177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103178   void * jresult ;
103179   std::string *arg1 = 0 ;
103180   Dali::ImageDimensions arg2 ;
103181   Dali::FittingMode::Type arg3 ;
103182   Dali::SamplingMode::Type arg4 ;
103183   Dali::ImageDimensions *argp2 ;
103184   Dali::ImageDimensions result;
103185
103186   if (!jarg1) {
103187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103188     return 0;
103189   }
103190   std::string arg1_str(jarg1);
103191   arg1 = &arg1_str;
103192   argp2 = (Dali::ImageDimensions *)jarg2;
103193   if (!argp2) {
103194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103195     return 0;
103196   }
103197   arg2 = *argp2;
103198   arg3 = (Dali::FittingMode::Type)jarg3;
103199   arg4 = (Dali::SamplingMode::Type)jarg4;
103200   {
103201     try {
103202       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103203     } catch (std::out_of_range& e) {
103204       {
103205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103206       };
103207     } catch (std::exception& e) {
103208       {
103209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103210       };
103211     } catch (...) {
103212       {
103213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103214       };
103215     }
103216   }
103217   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103218
103219   return jresult;
103220 }
103221
103222
103223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103224   void * jresult ;
103225   std::string *arg1 = 0 ;
103226   Dali::ImageDimensions arg2 ;
103227   Dali::FittingMode::Type arg3 ;
103228   Dali::ImageDimensions *argp2 ;
103229   Dali::ImageDimensions result;
103230
103231   if (!jarg1) {
103232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103233     return 0;
103234   }
103235   std::string arg1_str(jarg1);
103236   arg1 = &arg1_str;
103237   argp2 = (Dali::ImageDimensions *)jarg2;
103238   if (!argp2) {
103239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103240     return 0;
103241   }
103242   arg2 = *argp2;
103243   arg3 = (Dali::FittingMode::Type)jarg3;
103244   {
103245     try {
103246       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103247     } catch (std::out_of_range& e) {
103248       {
103249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103250       };
103251     } catch (std::exception& e) {
103252       {
103253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103254       };
103255     } catch (...) {
103256       {
103257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103258       };
103259     }
103260   }
103261   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103262
103263   return jresult;
103264 }
103265
103266
103267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103268   void * jresult ;
103269   std::string *arg1 = 0 ;
103270   Dali::ImageDimensions arg2 ;
103271   Dali::ImageDimensions *argp2 ;
103272   Dali::ImageDimensions result;
103273
103274   if (!jarg1) {
103275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103276     return 0;
103277   }
103278   std::string arg1_str(jarg1);
103279   arg1 = &arg1_str;
103280   argp2 = (Dali::ImageDimensions *)jarg2;
103281   if (!argp2) {
103282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103283     return 0;
103284   }
103285   arg2 = *argp2;
103286   {
103287     try {
103288       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103289     } catch (std::out_of_range& e) {
103290       {
103291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103292       };
103293     } catch (std::exception& e) {
103294       {
103295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103296       };
103297     } catch (...) {
103298       {
103299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103300       };
103301     }
103302   }
103303   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103304
103305   return jresult;
103306 }
103307
103308
103309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103310   void * jresult ;
103311   std::string *arg1 = 0 ;
103312   Dali::ImageDimensions result;
103313
103314   if (!jarg1) {
103315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103316     return 0;
103317   }
103318   std::string arg1_str(jarg1);
103319   arg1 = &arg1_str;
103320   {
103321     try {
103322       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103323     } catch (std::out_of_range& e) {
103324       {
103325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103326       };
103327     } catch (std::exception& e) {
103328       {
103329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103330       };
103331     } catch (...) {
103332       {
103333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103334       };
103335     }
103336   }
103337   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103338
103339   return jresult;
103340 }
103341
103342
103343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103344   void * jresult ;
103345   std::string *arg1 = 0 ;
103346   Dali::ImageDimensions arg2 ;
103347   Dali::FittingMode::Type arg3 ;
103348   Dali::SamplingMode::Type arg4 ;
103349   bool arg5 ;
103350   Dali::ImageDimensions *argp2 ;
103351   Dali::Devel::PixelBuffer result;
103352
103353   if (!jarg1) {
103354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103355     return 0;
103356   }
103357   std::string arg1_str(jarg1);
103358   arg1 = &arg1_str;
103359   argp2 = (Dali::ImageDimensions *)jarg2;
103360   if (!argp2) {
103361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103362     return 0;
103363   }
103364   arg2 = *argp2;
103365   arg3 = (Dali::FittingMode::Type)jarg3;
103366   arg4 = (Dali::SamplingMode::Type)jarg4;
103367   arg5 = jarg5 ? true : false;
103368   {
103369     try {
103370       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103371     } catch (std::out_of_range& e) {
103372       {
103373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103374       };
103375     } catch (std::exception& e) {
103376       {
103377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103378       };
103379     } catch (...) {
103380       {
103381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103382       };
103383     }
103384   }
103385   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103386
103387   return jresult;
103388 }
103389
103390
103391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103392   void * jresult ;
103393   std::string *arg1 = 0 ;
103394   Dali::ImageDimensions arg2 ;
103395   Dali::FittingMode::Type arg3 ;
103396   Dali::SamplingMode::Type arg4 ;
103397   Dali::ImageDimensions *argp2 ;
103398   Dali::Devel::PixelBuffer result;
103399
103400   if (!jarg1) {
103401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103402     return 0;
103403   }
103404   std::string arg1_str(jarg1);
103405   arg1 = &arg1_str;
103406   argp2 = (Dali::ImageDimensions *)jarg2;
103407   if (!argp2) {
103408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103409     return 0;
103410   }
103411   arg2 = *argp2;
103412   arg3 = (Dali::FittingMode::Type)jarg3;
103413   arg4 = (Dali::SamplingMode::Type)jarg4;
103414   {
103415     try {
103416       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103417     } catch (std::out_of_range& e) {
103418       {
103419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103420       };
103421     } catch (std::exception& e) {
103422       {
103423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103424       };
103425     } catch (...) {
103426       {
103427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103428       };
103429     }
103430   }
103431   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103432
103433   return jresult;
103434 }
103435
103436
103437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103438   void * jresult ;
103439   std::string *arg1 = 0 ;
103440   Dali::ImageDimensions arg2 ;
103441   Dali::FittingMode::Type arg3 ;
103442   Dali::ImageDimensions *argp2 ;
103443   Dali::Devel::PixelBuffer result;
103444
103445   if (!jarg1) {
103446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103447     return 0;
103448   }
103449   std::string arg1_str(jarg1);
103450   arg1 = &arg1_str;
103451   argp2 = (Dali::ImageDimensions *)jarg2;
103452   if (!argp2) {
103453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103454     return 0;
103455   }
103456   arg2 = *argp2;
103457   arg3 = (Dali::FittingMode::Type)jarg3;
103458   {
103459     try {
103460       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103461     } catch (std::out_of_range& e) {
103462       {
103463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103464       };
103465     } catch (std::exception& e) {
103466       {
103467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103468       };
103469     } catch (...) {
103470       {
103471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103472       };
103473     }
103474   }
103475   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103476
103477   return jresult;
103478 }
103479
103480
103481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103482   void * jresult ;
103483   std::string *arg1 = 0 ;
103484   Dali::ImageDimensions arg2 ;
103485   Dali::ImageDimensions *argp2 ;
103486   Dali::Devel::PixelBuffer result;
103487
103488   if (!jarg1) {
103489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103490     return 0;
103491   }
103492   std::string arg1_str(jarg1);
103493   arg1 = &arg1_str;
103494   argp2 = (Dali::ImageDimensions *)jarg2;
103495   if (!argp2) {
103496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103497     return 0;
103498   }
103499   arg2 = *argp2;
103500   {
103501     try {
103502       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103503     } catch (std::out_of_range& e) {
103504       {
103505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103506       };
103507     } catch (std::exception& e) {
103508       {
103509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103510       };
103511     } catch (...) {
103512       {
103513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103514       };
103515     }
103516   }
103517   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103518
103519   return jresult;
103520 }
103521
103522
103523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103524   void * jresult ;
103525   std::string *arg1 = 0 ;
103526   Dali::Devel::PixelBuffer result;
103527
103528   if (!jarg1) {
103529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103530     return 0;
103531   }
103532   std::string arg1_str(jarg1);
103533   arg1 = &arg1_str;
103534   {
103535     try {
103536       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103537     } catch (std::out_of_range& e) {
103538       {
103539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103540       };
103541     } catch (std::exception& e) {
103542       {
103543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103544       };
103545     } catch (...) {
103546       {
103547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103548       };
103549     }
103550   }
103551   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103552
103553   return jresult;
103554 }
103555
103556
103557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetMaxTextureSize(unsigned int jarg1) {
103558   unsigned int arg1 ;
103559
103560   arg1 = (unsigned int)jarg1;
103561   {
103562     try {
103563       Dali::SetMaxTextureSize(arg1);
103564     } catch (std::out_of_range& e) {
103565       {
103566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103567       };
103568     } catch (std::exception& e) {
103569       {
103570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103571       };
103572     } catch (...) {
103573       {
103574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103575       };
103576     }
103577   }
103578 }
103579
103580
103581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetMaxTextureSize() {
103582   unsigned int jresult ;
103583   unsigned int result;
103584
103585   {
103586     try {
103587       result = (unsigned int)Dali::GetMaxTextureSize();
103588     } catch (std::out_of_range& e) {
103589       {
103590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103591       };
103592     } catch (std::exception& e) {
103593       {
103594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103595       };
103596     } catch (...) {
103597       {
103598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103599       };
103600     }
103601   }
103602   jresult = result;
103603   return jresult;
103604 }
103605
103606
103607 #ifdef __cplusplus
103608 }
103609 #endif
103610